// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 GxcGrammer\\Gxc.g 2009-12-17 22:47:10

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System.Collections.Generic;



using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;

using Antlr.Runtime.Tree;

namespace  gxc2csharp.Translator.GxcToCTransform 
{
public partial class GxcParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"CONDITIONAL_EXPRESSION", 
		"FUNCTION_CALL", 
		"ASSIGNMENT", 
		"CODE_BLOCK", 
		"CASE", 
		"DEFAULT_CASE", 
		"VARIABLE", 
		"UNARY_INCREMENT", 
		"UNARY_DECREMENT", 
		"STRING_LITERAL", 
		"IDENTIFIER", 
		"DECIMAL_LITERAL", 
		"HEX_LITERAL", 
		"OCTAL_LITERAL", 
		"CHARACTER_LITERAL", 
		"FLOATING_POINT_LITERAL", 
		"IF", 
		"ELSE", 
		"SWITCH", 
		"WHILE", 
		"DO", 
		"FOR", 
		"CONTINUE", 
		"BREAK", 
		"LINE_COMMENT", 
		"COMMENT", 
		"LETTER", 
		"EscapeSequence", 
		"HexDigit", 
		"IntegerTypeSuffix", 
		"Exponent", 
		"FloatTypeSuffix", 
		"OctalEscape", 
		"UnicodeEscape", 
		"WS", 
		"LINE_COMMAND", 
		"STRAY_BAKSLASH", 
		"'NAME'", 
		"'='", 
		"'VERSION'", 
		"'DESCRIPTION'", 
		"'RESOURCE'", 
		"'typedef'", 
		"','", 
		"';'", 
		"'('", 
		"')'", 
		"'void'", 
		"'int'", 
		"'real'", 
		"'string'", 
		"'var'", 
		"'['", 
		"']'", 
		"'+'", 
		"'-'", 
		"'*'", 
		"'/'", 
		"'%'", 
		"'++'", 
		"'--'", 
		"'sizeof'", 
		"'&'", 
		"'~'", 
		"'!'", 
		"'*='", 
		"'/='", 
		"'%='", 
		"'+='", 
		"'-='", 
		"'<<='", 
		"'>>='", 
		"'&='", 
		"'^='", 
		"'|='", 
		"'?'", 
		"':'", 
		"'||'", 
		"'&&'", 
		"'|'", 
		"'^'", 
		"'=='", 
		"'!='", 
		"'<'", 
		"'>'", 
		"'<='", 
		"'>='", 
		"'<<'", 
		"'>>'", 
		"'case'", 
		"'default'", 
		"'{'", 
		"'}'", 
		"'goto'"
    };

    public const int WHILE = 23;
    public const int FloatTypeSuffix = 35;
    public const int LETTER = 30;
    public const int CASE = 8;
    public const int DO = 24;
    public const int EOF = -1;
    public const int BREAK = 27;
    public const int T__93 = 93;
    public const int T__94 = 94;
    public const int T__91 = 91;
    public const int T__92 = 92;
    public const int STRING_LITERAL = 13;
    public const int T__90 = 90;
    public const int FLOATING_POINT_LITERAL = 19;
    public const int COMMENT = 29;
    public const int T__97 = 97;
    public const int T__96 = 96;
    public const int T__95 = 95;
    public const int T__80 = 80;
    public const int T__81 = 81;
    public const int T__82 = 82;
    public const int T__83 = 83;
    public const int LINE_COMMENT = 28;
    public const int IntegerTypeSuffix = 33;
    public const int SWITCH = 22;
    public const int UNARY_INCREMENT = 11;
    public const int ELSE = 21;
    public const int CHARACTER_LITERAL = 18;
    public const int T__85 = 85;
    public const int T__84 = 84;
    public const int T__87 = 87;
    public const int T__86 = 86;
    public const int T__89 = 89;
    public const int T__88 = 88;
    public const int WS = 38;
    public const int T__71 = 71;
    public const int T__72 = 72;
    public const int VARIABLE = 10;
    public const int T__70 = 70;
    public const int LINE_COMMAND = 39;
    public const int T__76 = 76;
    public const int T__75 = 75;
    public const int FUNCTION_CALL = 5;
    public const int T__74 = 74;
    public const int T__73 = 73;
    public const int DECIMAL_LITERAL = 15;
    public const int EscapeSequence = 31;
    public const int T__79 = 79;
    public const int T__78 = 78;
    public const int T__77 = 77;
    public const int T__68 = 68;
    public const int T__69 = 69;
    public const int T__66 = 66;
    public const int T__67 = 67;
    public const int T__64 = 64;
    public const int T__65 = 65;
    public const int T__62 = 62;
    public const int T__63 = 63;
    public const int FOR = 25;
    public const int Exponent = 34;
    public const int T__61 = 61;
    public const int T__60 = 60;
    public const int UNARY_DECREMENT = 12;
    public const int HexDigit = 32;
    public const int IF = 20;
    public const int T__55 = 55;
    public const int T__56 = 56;
    public const int T__57 = 57;
    public const int T__58 = 58;
    public const int T__51 = 51;
    public const int T__52 = 52;
    public const int T__53 = 53;
    public const int T__54 = 54;
    public const int CONTINUE = 26;
    public const int CONDITIONAL_EXPRESSION = 4;
    public const int IDENTIFIER = 14;
    public const int T__59 = 59;
    public const int HEX_LITERAL = 16;
    public const int T__50 = 50;
    public const int T__42 = 42;
    public const int T__43 = 43;
    public const int T__41 = 41;
    public const int T__46 = 46;
    public const int T__47 = 47;
    public const int T__44 = 44;
    public const int T__45 = 45;
    public const int T__48 = 48;
    public const int T__49 = 49;
    public const int OCTAL_LITERAL = 17;
    public const int STRAY_BAKSLASH = 40;
    public const int UnicodeEscape = 37;
    public const int CODE_BLOCK = 7;
    public const int ASSIGNMENT = 6;
    public const int DEFAULT_CASE = 9;
    public const int OctalEscape = 36;

    // delegates
    // delegators

    protected class Symbols_scope 
    {
        protected internal HashSet<string> types;
    }
    protected Stack Symbols_stack = new Stack();



        public GxcParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public GxcParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();
            this.state.ruleMemo = new Hashtable[163+1];
             
             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return GxcParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "GxcGrammer\\Gxc.g"; }
    }


    	bool isTypeName(String name) {
        		
        		return true;
        	}
      


    public class translation_unit_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "translation_unit"
    // GxcGrammer\\Gxc.g:45:1: translation_unit : ( gx_meta_declarations )+ ( declaration )* compound_statement ;
    public GxcParser.translation_unit_return translation_unit() // throws RecognitionException [1]
    {   
        Symbols_stack.Push(new Symbols_scope());

        GxcParser.translation_unit_return retval = new GxcParser.translation_unit_return();
        retval.Start = input.LT(1);
        int translation_unit_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.gx_meta_declarations_return gx_meta_declarations1 = default(GxcParser.gx_meta_declarations_return);

        GxcParser.declaration_return declaration2 = default(GxcParser.declaration_return);

        GxcParser.compound_statement_return compound_statement3 = default(GxcParser.compound_statement_return);




          ((Symbols_scope)Symbols_stack.Peek()).types =  new HashSet<string>();
          GxVariables = new Dictionary<string, string> ();
          PInvokeFunctions = new  List<string> ();
          Operators = new Dictionary<string, int>();

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 1) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:58:2: ( ( gx_meta_declarations )+ ( declaration )* compound_statement )
            // GxcGrammer\\Gxc.g:58:4: ( gx_meta_declarations )+ ( declaration )* compound_statement
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// GxcGrammer\\Gxc.g:58:4: ( gx_meta_declarations )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    alt1 = dfa1.Predict(input);
            	    switch (alt1) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: gx_meta_declarations
            			    {
            			    	PushFollow(FOLLOW_gx_meta_declarations_in_translation_unit191);
            			    	gx_meta_declarations1 = gx_meta_declarations();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, gx_meta_declarations1.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee1 =
            		                new EarlyExitException(1, input);
            		            throw eee1;
            	    }
            	    cnt1++;
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements

            	// GxcGrammer\\Gxc.g:58:26: ( declaration )*
            	do 
            	{
            	    int alt2 = 2;
            	    int LA2_0 = input.LA(1);

            	    if ( (LA2_0 == IDENTIFIER || LA2_0 == 46 || (LA2_0 >= 51 && LA2_0 <= 54) || LA2_0 == 56) )
            	    {
            	        alt2 = 1;
            	    }


            	    switch (alt2) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: declaration
            			    {
            			    	PushFollow(FOLLOW_declaration_in_translation_unit194);
            			    	declaration2 = declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, declaration2.Tree);

            			    }
            			    break;

            			default:
            			    goto loop2;
            	    }
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whining that label 'loop2' has no statements

            	PushFollow(FOLLOW_compound_statement_in_translation_unit197);
            	compound_statement3 = compound_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, compound_statement3.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 1, translation_unit_StartIndex); 
            }
            Symbols_stack.Pop();

        }
        return retval;
    }
    // $ANTLR end "translation_unit"

    public class gx_meta_declarations_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "gx_meta_declarations"
    // GxcGrammer\\Gxc.g:63:1: gx_meta_declarations : gx_meta_data ( gx_resource )* ;
    public GxcParser.gx_meta_declarations_return gx_meta_declarations() // throws RecognitionException [1]
    {   
        GxcParser.gx_meta_declarations_return retval = new GxcParser.gx_meta_declarations_return();
        retval.Start = input.LT(1);
        int gx_meta_declarations_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.gx_meta_data_return gx_meta_data4 = default(GxcParser.gx_meta_data_return);

        GxcParser.gx_resource_return gx_resource5 = default(GxcParser.gx_resource_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 2) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:64:4: ( gx_meta_data ( gx_resource )* )
            // GxcGrammer\\Gxc.g:64:5: gx_meta_data ( gx_resource )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_gx_meta_data_in_gx_meta_declarations212);
            	gx_meta_data4 = gx_meta_data();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	// GxcGrammer\\Gxc.g:64:19: ( gx_resource )*
            	do 
            	{
            	    int alt3 = 2;
            	    alt3 = dfa3.Predict(input);
            	    switch (alt3) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: gx_resource
            			    {
            			    	PushFollow(FOLLOW_gx_resource_in_gx_meta_declarations215);
            			    	gx_resource5 = gx_resource();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, gx_resource5.Tree);

            			    }
            			    break;

            			default:
            			    goto loop3;
            	    }
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 2, gx_meta_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "gx_meta_declarations"

    public class gx_meta_data_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "gx_meta_data"
    // GxcGrammer\\Gxc.g:67:1: gx_meta_data : ( 'NAME' '=' STRING_LITERAL | 'VERSION' '=' STRING_LITERAL | 'DESCRIPTION' '=' STRING_LITERAL );
    public GxcParser.gx_meta_data_return gx_meta_data() // throws RecognitionException [1]
    {   
        GxcParser.gx_meta_data_return retval = new GxcParser.gx_meta_data_return();
        retval.Start = input.LT(1);
        int gx_meta_data_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal6 = null;
        IToken char_literal7 = null;
        IToken STRING_LITERAL8 = null;
        IToken string_literal9 = null;
        IToken char_literal10 = null;
        IToken STRING_LITERAL11 = null;
        IToken string_literal12 = null;
        IToken char_literal13 = null;
        IToken STRING_LITERAL14 = null;

        CommonTree string_literal6_tree=null;
        CommonTree char_literal7_tree=null;
        CommonTree STRING_LITERAL8_tree=null;
        CommonTree string_literal9_tree=null;
        CommonTree char_literal10_tree=null;
        CommonTree STRING_LITERAL11_tree=null;
        CommonTree string_literal12_tree=null;
        CommonTree char_literal13_tree=null;
        CommonTree STRING_LITERAL14_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 3) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:68:4: ( 'NAME' '=' STRING_LITERAL | 'VERSION' '=' STRING_LITERAL | 'DESCRIPTION' '=' STRING_LITERAL )
            int alt4 = 3;
            switch ( input.LA(1) ) 
            {
            case 41:
            	{
                alt4 = 1;
                }
                break;
            case 43:
            	{
                alt4 = 2;
                }
                break;
            case 44:
            	{
                alt4 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d4s0 =
            	        new NoViableAltException("", 4, 0, input);

            	    throw nvae_d4s0;
            }

            switch (alt4) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:68:6: 'NAME' '=' STRING_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal6=(IToken)Match(input,41,FOLLOW_41_in_gx_meta_data232); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal6_tree = (CommonTree)adaptor.Create(string_literal6);
                    		adaptor.AddChild(root_0, string_literal6_tree);
                    	}
                    	char_literal7=(IToken)Match(input,42,FOLLOW_42_in_gx_meta_data234); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal7_tree = (CommonTree)adaptor.Create(char_literal7);
                    		adaptor.AddChild(root_0, char_literal7_tree);
                    	}
                    	STRING_LITERAL8=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_gx_meta_data236); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{STRING_LITERAL8_tree = (CommonTree)adaptor.Create(STRING_LITERAL8);
                    		adaptor.AddChild(root_0, STRING_LITERAL8_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  GxName = input.LT(-1).Text;
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:69:6: 'VERSION' '=' STRING_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal9=(IToken)Match(input,43,FOLLOW_43_in_gx_meta_data246); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal9_tree = (CommonTree)adaptor.Create(string_literal9);
                    		adaptor.AddChild(root_0, string_literal9_tree);
                    	}
                    	char_literal10=(IToken)Match(input,42,FOLLOW_42_in_gx_meta_data248); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal10_tree = (CommonTree)adaptor.Create(char_literal10);
                    		adaptor.AddChild(root_0, char_literal10_tree);
                    	}
                    	STRING_LITERAL11=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_gx_meta_data250); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{STRING_LITERAL11_tree = (CommonTree)adaptor.Create(STRING_LITERAL11);
                    		adaptor.AddChild(root_0, STRING_LITERAL11_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  GxVersion= input.LT(-1).Text;
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:70:6: 'DESCRIPTION' '=' STRING_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal12=(IToken)Match(input,44,FOLLOW_44_in_gx_meta_data259); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal12_tree = (CommonTree)adaptor.Create(string_literal12);
                    		adaptor.AddChild(root_0, string_literal12_tree);
                    	}
                    	char_literal13=(IToken)Match(input,42,FOLLOW_42_in_gx_meta_data261); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal13_tree = (CommonTree)adaptor.Create(char_literal13);
                    		adaptor.AddChild(root_0, char_literal13_tree);
                    	}
                    	STRING_LITERAL14=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_gx_meta_data263); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{STRING_LITERAL14_tree = (CommonTree)adaptor.Create(STRING_LITERAL14);
                    		adaptor.AddChild(root_0, STRING_LITERAL14_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  GxDescription= input.LT(-1).Text;
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 3, gx_meta_data_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "gx_meta_data"

    public class gx_resource_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "gx_resource"
    // GxcGrammer\\Gxc.g:75:2: gx_resource : 'RESOURCE' '=' STRING_LITERAL ;
    public GxcParser.gx_resource_return gx_resource() // throws RecognitionException [1]
    {   
        GxcParser.gx_resource_return retval = new GxcParser.gx_resource_return();
        retval.Start = input.LT(1);
        int gx_resource_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal15 = null;
        IToken char_literal16 = null;
        IToken STRING_LITERAL17 = null;

        CommonTree string_literal15_tree=null;
        CommonTree char_literal16_tree=null;
        CommonTree STRING_LITERAL17_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 4) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:76:4: ( 'RESOURCE' '=' STRING_LITERAL )
            // GxcGrammer\\Gxc.g:76:5: 'RESOURCE' '=' STRING_LITERAL
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal15=(IToken)Match(input,45,FOLLOW_45_in_gx_resource283); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal15_tree = (CommonTree)adaptor.Create(string_literal15);
            		adaptor.AddChild(root_0, string_literal15_tree);
            	}
            	char_literal16=(IToken)Match(input,42,FOLLOW_42_in_gx_resource285); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal16_tree = (CommonTree)adaptor.Create(char_literal16);
            		adaptor.AddChild(root_0, char_literal16_tree);
            	}
            	STRING_LITERAL17=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_gx_resource287); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{STRING_LITERAL17_tree = (CommonTree)adaptor.Create(STRING_LITERAL17);
            		adaptor.AddChild(root_0, STRING_LITERAL17_tree);
            	}
            	if ( (state.backtracking==0) )
            	{
            	  ReadInGrcFile(STRING_LITERAL17.Text);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 4, gx_resource_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "gx_resource"

    public class declaration_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "declaration"
    // GxcGrammer\\Gxc.g:80:1: declaration : ( type_declaration | function_declaration | variable_declaration );
    public GxcParser.declaration_return declaration() // throws RecognitionException [1]
    {   
        GxcParser.declaration_return retval = new GxcParser.declaration_return();
        retval.Start = input.LT(1);
        int declaration_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.type_declaration_return type_declaration18 = default(GxcParser.type_declaration_return);

        GxcParser.function_declaration_return function_declaration19 = default(GxcParser.function_declaration_return);

        GxcParser.variable_declaration_return variable_declaration20 = default(GxcParser.variable_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 5) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:81:2: ( type_declaration | function_declaration | variable_declaration )
            int alt5 = 3;
            alt5 = dfa5.Predict(input);
            switch (alt5) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:81:3: type_declaration
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_declaration_in_declaration304);
                    	type_declaration18 = type_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:82:3: function_declaration
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_function_declaration_in_declaration310);
                    	function_declaration19 = function_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:83:3: variable_declaration
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_variable_declaration_in_declaration315);
                    	variable_declaration20 = variable_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 5, declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "declaration"

    protected class type_declaration_scope 
    {
        protected internal bool typedef;
    }
    protected Stack type_declaration_stack = new Stack();

    public class type_declaration_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "type_declaration"
    // GxcGrammer\\Gxc.g:86:1: type_declaration : 'typedef' IDENTIFIER ( ',' IDENTIFIER )* ';' ;
    public GxcParser.type_declaration_return type_declaration() // throws RecognitionException [1]
    {   
        type_declaration_stack.Push(new type_declaration_scope());
        GxcParser.type_declaration_return retval = new GxcParser.type_declaration_return();
        retval.Start = input.LT(1);
        int type_declaration_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal21 = null;
        IToken IDENTIFIER22 = null;
        IToken char_literal23 = null;
        IToken IDENTIFIER24 = null;
        IToken char_literal25 = null;

        CommonTree string_literal21_tree=null;
        CommonTree IDENTIFIER22_tree=null;
        CommonTree char_literal23_tree=null;
        CommonTree IDENTIFIER24_tree=null;
        CommonTree char_literal25_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 6) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:90:4: ( 'typedef' IDENTIFIER ( ',' IDENTIFIER )* ';' )
            // GxcGrammer\\Gxc.g:90:6: 'typedef' IDENTIFIER ( ',' IDENTIFIER )* ';'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal21=(IToken)Match(input,46,FOLLOW_46_in_type_declaration337); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal21_tree = (CommonTree)adaptor.Create(string_literal21);
            		adaptor.AddChild(root_0, string_literal21_tree);
            	}
            	IDENTIFIER22=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_type_declaration339); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{IDENTIFIER22_tree = (CommonTree)adaptor.Create(IDENTIFIER22);
            		adaptor.AddChild(root_0, IDENTIFIER22_tree);
            	}
            	// GxcGrammer\\Gxc.g:90:27: ( ',' IDENTIFIER )*
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0 == 47) )
            	    {
            	        alt6 = 1;
            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:90:28: ',' IDENTIFIER
            			    {
            			    	char_literal23=(IToken)Match(input,47,FOLLOW_47_in_type_declaration342); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal23_tree = (CommonTree)adaptor.Create(char_literal23);
            			    		adaptor.AddChild(root_0, char_literal23_tree);
            			    	}
            			    	IDENTIFIER24=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_type_declaration344); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{IDENTIFIER24_tree = (CommonTree)adaptor.Create(IDENTIFIER24);
            			    		adaptor.AddChild(root_0, IDENTIFIER24_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    goto loop6;
            	    }
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whining that label 'loop6' has no statements

            	char_literal25=(IToken)Match(input,48,FOLLOW_48_in_type_declaration348); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal25_tree = (CommonTree)adaptor.Create(char_literal25);
            		adaptor.AddChild(root_0, char_literal25_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 6, type_declaration_StartIndex); 
            }
            type_declaration_stack.Pop();
        }
        return retval;
    }
    // $ANTLR end "type_declaration"

    protected class function_declaration_scope 
    {
        protected internal string dll;
        protected internal List<string>argTypes;
        protected internal string return_type;
    }
    protected Stack function_declaration_stack = new Stack();

    public class function_declaration_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "function_declaration"
    // GxcGrammer\\Gxc.g:92:1: function_declaration : ( dll_specifier )* returntype_specifier IDENTIFIER '(' ( func_declaration_arugments )* ')' ';' ;
    public GxcParser.function_declaration_return function_declaration() // throws RecognitionException [1]
    {   
        function_declaration_stack.Push(new function_declaration_scope());
        GxcParser.function_declaration_return retval = new GxcParser.function_declaration_return();
        retval.Start = input.LT(1);
        int function_declaration_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IDENTIFIER28 = null;
        IToken char_literal29 = null;
        IToken char_literal31 = null;
        IToken char_literal32 = null;
        GxcParser.dll_specifier_return dll_specifier26 = default(GxcParser.dll_specifier_return);

        GxcParser.returntype_specifier_return returntype_specifier27 = default(GxcParser.returntype_specifier_return);

        GxcParser.func_declaration_arugments_return func_declaration_arugments30 = default(GxcParser.func_declaration_arugments_return);


        CommonTree IDENTIFIER28_tree=null;
        CommonTree char_literal29_tree=null;
        CommonTree char_literal31_tree=null;
        CommonTree char_literal32_tree=null;


        ((function_declaration_scope)function_declaration_stack.Peek()).argTypes =  new List<string>();

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 7) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:101:4: ( ( dll_specifier )* returntype_specifier IDENTIFIER '(' ( func_declaration_arugments )* ')' ';' )
            // GxcGrammer\\Gxc.g:101:6: ( dll_specifier )* returntype_specifier IDENTIFIER '(' ( func_declaration_arugments )* ')' ';'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// GxcGrammer\\Gxc.g:101:6: ( dll_specifier )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( (LA7_0 == 56) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: dll_specifier
            			    {
            			    	PushFollow(FOLLOW_dll_specifier_in_function_declaration372);
            			    	dll_specifier26 = dll_specifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, dll_specifier26.Tree);

            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements

            	PushFollow(FOLLOW_returntype_specifier_in_function_declaration375);
            	returntype_specifier27 = returntype_specifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, returntype_specifier27.Tree);
            	IDENTIFIER28=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_function_declaration377); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{IDENTIFIER28_tree = (CommonTree)adaptor.Create(IDENTIFIER28);
            		adaptor.AddChild(root_0, IDENTIFIER28_tree);
            	}
            	char_literal29=(IToken)Match(input,49,FOLLOW_49_in_function_declaration379); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal29_tree = (CommonTree)adaptor.Create(char_literal29);
            		adaptor.AddChild(root_0, char_literal29_tree);
            	}
            	// GxcGrammer\\Gxc.g:101:57: ( func_declaration_arugments )*
            	do 
            	{
            	    int alt8 = 2;
            	    int LA8_0 = input.LA(1);

            	    if ( (LA8_0 == IDENTIFIER || (LA8_0 >= 51 && LA8_0 <= 55)) )
            	    {
            	        alt8 = 1;
            	    }


            	    switch (alt8) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: func_declaration_arugments
            			    {
            			    	PushFollow(FOLLOW_func_declaration_arugments_in_function_declaration381);
            			    	func_declaration_arugments30 = func_declaration_arugments();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, func_declaration_arugments30.Tree);

            			    }
            			    break;

            			default:
            			    goto loop8;
            	    }
            	} while (true);

            	loop8:
            		;	// Stops C# compiler whining that label 'loop8' has no statements

            	char_literal31=(IToken)Match(input,50,FOLLOW_50_in_function_declaration384); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal31_tree = (CommonTree)adaptor.Create(char_literal31);
            		adaptor.AddChild(root_0, char_literal31_tree);
            	}
            	char_literal32=(IToken)Match(input,48,FOLLOW_48_in_function_declaration386); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal32_tree = (CommonTree)adaptor.Create(char_literal32);
            		adaptor.AddChild(root_0, char_literal32_tree);
            	}
            	if ( (state.backtracking==0) )
            	{
            	  AddFunctionDeclaration(IDENTIFIER28.Text,((function_declaration_scope)function_declaration_stack.Peek()).dll,((function_declaration_scope)function_declaration_stack.Peek()).return_type,((function_declaration_scope)function_declaration_stack.Peek()).argTypes);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 7, function_declaration_StartIndex); 
            }
            function_declaration_stack.Pop();
        }
        return retval;
    }
    // $ANTLR end "function_declaration"

    protected class variable_declaration_scope 
    {
        protected internal List<string> variables;
        protected internal string type;
        protected internal int size;
    }
    protected Stack variable_declaration_stack = new Stack();

    public class variable_declaration_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "variable_declaration"
    // GxcGrammer\\Gxc.g:106:1: variable_declaration : type_specifier identifier_list ';' ;
    public GxcParser.variable_declaration_return variable_declaration() // throws RecognitionException [1]
    {   
        variable_declaration_stack.Push(new variable_declaration_scope());
        GxcParser.variable_declaration_return retval = new GxcParser.variable_declaration_return();
        retval.Start = input.LT(1);
        int variable_declaration_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal35 = null;
        GxcParser.type_specifier_return type_specifier33 = default(GxcParser.type_specifier_return);

        GxcParser.identifier_list_return identifier_list34 = default(GxcParser.identifier_list_return);


        CommonTree char_literal35_tree=null;


          ((variable_declaration_scope)variable_declaration_stack.Peek()).variables =  new List<string>();
          ((variable_declaration_scope)variable_declaration_stack.Peek()).size = 1;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 8) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:116:4: ( type_specifier identifier_list ';' )
            // GxcGrammer\\Gxc.g:116:6: type_specifier identifier_list ';'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_specifier_in_variable_declaration423);
            	type_specifier33 = type_specifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_specifier33.Tree);
            	PushFollow(FOLLOW_identifier_list_in_variable_declaration425);
            	identifier_list34 = identifier_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier_list34.Tree);
            	char_literal35=(IToken)Match(input,48,FOLLOW_48_in_variable_declaration427); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal35_tree = (CommonTree)adaptor.Create(char_literal35);
            		adaptor.AddChild(root_0, char_literal35_tree);
            	}
            	if ( (state.backtracking==0) )
            	{
            	  AddVariables(((variable_declaration_scope)variable_declaration_stack.Peek()).type,((variable_declaration_scope)variable_declaration_stack.Peek()).size, ((variable_declaration_scope)variable_declaration_stack.Peek()).variables);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 8, variable_declaration_StartIndex); 
            }
            variable_declaration_stack.Pop();
        }
        return retval;
    }
    // $ANTLR end "variable_declaration"

    public class returntype_specifier_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "returntype_specifier"
    // GxcGrammer\\Gxc.g:118:2: returntype_specifier : ( 'void' | 'int' | 'real' | 'string' | type_id );
    public GxcParser.returntype_specifier_return returntype_specifier() // throws RecognitionException [1]
    {   
        GxcParser.returntype_specifier_return retval = new GxcParser.returntype_specifier_return();
        retval.Start = input.LT(1);
        int returntype_specifier_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal36 = null;
        IToken string_literal37 = null;
        IToken string_literal38 = null;
        IToken string_literal39 = null;
        GxcParser.type_id_return type_id40 = default(GxcParser.type_id_return);


        CommonTree string_literal36_tree=null;
        CommonTree string_literal37_tree=null;
        CommonTree string_literal38_tree=null;
        CommonTree string_literal39_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 9) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:119:4: ( 'void' | 'int' | 'real' | 'string' | type_id )
            int alt9 = 5;
            switch ( input.LA(1) ) 
            {
            case 51:
            	{
                alt9 = 1;
                }
                break;
            case 52:
            	{
                alt9 = 2;
                }
                break;
            case 53:
            	{
                alt9 = 3;
                }
                break;
            case 54:
            	{
                alt9 = 4;
                }
                break;
            case IDENTIFIER:
            	{
                alt9 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d9s0 =
            	        new NoViableAltException("", 9, 0, input);

            	    throw nvae_d9s0;
            }

            switch (alt9) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:119:6: 'void'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal36=(IToken)Match(input,51,FOLLOW_51_in_returntype_specifier445); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal36_tree = (CommonTree)adaptor.Create(string_literal36);
                    		adaptor.AddChild(root_0, string_literal36_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).return_type = "void";
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:120:4: 'int'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal37=(IToken)Match(input,52,FOLLOW_52_in_returntype_specifier452); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal37_tree = (CommonTree)adaptor.Create(string_literal37);
                    		adaptor.AddChild(root_0, string_literal37_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).return_type = "int";
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:121:4: 'real'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal38=(IToken)Match(input,53,FOLLOW_53_in_returntype_specifier460); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal38_tree = (CommonTree)adaptor.Create(string_literal38);
                    		adaptor.AddChild(root_0, string_literal38_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).return_type = "real";
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:122:4: 'string'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal39=(IToken)Match(input,54,FOLLOW_54_in_returntype_specifier467); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal39_tree = (CommonTree)adaptor.Create(string_literal39);
                    		adaptor.AddChild(root_0, string_literal39_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).return_type = "string";
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:123:4: type_id
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_id_in_returntype_specifier474);
                    	type_id40 = type_id();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_id40.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).return_type = input.LT(-1).Text;
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 9, returntype_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "returntype_specifier"

    public class func_declaration_specifiers_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "func_declaration_specifiers"
    // GxcGrammer\\Gxc.g:127:2: func_declaration_specifiers : ( 'void' | 'int' | 'real' | 'string' | type_id | 'var' 'void' | 'var' 'int' | 'var' 'real' | 'var' 'string' | 'var' type_id );
    public GxcParser.func_declaration_specifiers_return func_declaration_specifiers() // throws RecognitionException [1]
    {   
        GxcParser.func_declaration_specifiers_return retval = new GxcParser.func_declaration_specifiers_return();
        retval.Start = input.LT(1);
        int func_declaration_specifiers_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal41 = null;
        IToken string_literal42 = null;
        IToken string_literal43 = null;
        IToken string_literal44 = null;
        IToken string_literal46 = null;
        IToken string_literal47 = null;
        IToken string_literal48 = null;
        IToken string_literal49 = null;
        IToken string_literal50 = null;
        IToken string_literal51 = null;
        IToken string_literal52 = null;
        IToken string_literal53 = null;
        IToken string_literal54 = null;
        GxcParser.type_id_return type_id45 = default(GxcParser.type_id_return);

        GxcParser.type_id_return type_id55 = default(GxcParser.type_id_return);


        CommonTree string_literal41_tree=null;
        CommonTree string_literal42_tree=null;
        CommonTree string_literal43_tree=null;
        CommonTree string_literal44_tree=null;
        CommonTree string_literal46_tree=null;
        CommonTree string_literal47_tree=null;
        CommonTree string_literal48_tree=null;
        CommonTree string_literal49_tree=null;
        CommonTree string_literal50_tree=null;
        CommonTree string_literal51_tree=null;
        CommonTree string_literal52_tree=null;
        CommonTree string_literal53_tree=null;
        CommonTree string_literal54_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 10) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:128:2: ( 'void' | 'int' | 'real' | 'string' | type_id | 'var' 'void' | 'var' 'int' | 'var' 'real' | 'var' 'string' | 'var' type_id )
            int alt10 = 10;
            alt10 = dfa10.Predict(input);
            switch (alt10) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:128:4: 'void'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal41=(IToken)Match(input,51,FOLLOW_51_in_func_declaration_specifiers493); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal41_tree = (CommonTree)adaptor.Create(string_literal41);
                    		adaptor.AddChild(root_0, string_literal41_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("void");
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:129:4: 'int'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal42=(IToken)Match(input,52,FOLLOW_52_in_func_declaration_specifiers500); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal42_tree = (CommonTree)adaptor.Create(string_literal42);
                    		adaptor.AddChild(root_0, string_literal42_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("int");
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:130:4: 'real'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal43=(IToken)Match(input,53,FOLLOW_53_in_func_declaration_specifiers508); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal43_tree = (CommonTree)adaptor.Create(string_literal43);
                    		adaptor.AddChild(root_0, string_literal43_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("real");
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:131:4: 'string'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal44=(IToken)Match(input,54,FOLLOW_54_in_func_declaration_specifiers515); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal44_tree = (CommonTree)adaptor.Create(string_literal44);
                    		adaptor.AddChild(root_0, string_literal44_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("string");
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:132:4: type_id
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_id_in_func_declaration_specifiers522);
                    	type_id45 = type_id();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_id45.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add(input.LT(-1).Text);
                    	}

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:134:4: 'var' 'void'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal46=(IToken)Match(input,55,FOLLOW_55_in_func_declaration_specifiers544); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal46_tree = (CommonTree)adaptor.Create(string_literal46);
                    		adaptor.AddChild(root_0, string_literal46_tree);
                    	}
                    	string_literal47=(IToken)Match(input,51,FOLLOW_51_in_func_declaration_specifiers546); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal47_tree = (CommonTree)adaptor.Create(string_literal47);
                    		adaptor.AddChild(root_0, string_literal47_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("ref void/*really!!!!*/");
                    	}

                    }
                    break;
                case 7 :
                    // GxcGrammer\\Gxc.g:135:4: 'var' 'int'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal48=(IToken)Match(input,55,FOLLOW_55_in_func_declaration_specifiers553); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal48_tree = (CommonTree)adaptor.Create(string_literal48);
                    		adaptor.AddChild(root_0, string_literal48_tree);
                    	}
                    	string_literal49=(IToken)Match(input,52,FOLLOW_52_in_func_declaration_specifiers555); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal49_tree = (CommonTree)adaptor.Create(string_literal49);
                    		adaptor.AddChild(root_0, string_literal49_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("ref int");
                    	}

                    }
                    break;
                case 8 :
                    // GxcGrammer\\Gxc.g:136:4: 'var' 'real'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal50=(IToken)Match(input,55,FOLLOW_55_in_func_declaration_specifiers563); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal50_tree = (CommonTree)adaptor.Create(string_literal50);
                    		adaptor.AddChild(root_0, string_literal50_tree);
                    	}
                    	string_literal51=(IToken)Match(input,53,FOLLOW_53_in_func_declaration_specifiers565); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal51_tree = (CommonTree)adaptor.Create(string_literal51);
                    		adaptor.AddChild(root_0, string_literal51_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("ref real");
                    	}

                    }
                    break;
                case 9 :
                    // GxcGrammer\\Gxc.g:137:4: 'var' 'string'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal52=(IToken)Match(input,55,FOLLOW_55_in_func_declaration_specifiers572); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal52_tree = (CommonTree)adaptor.Create(string_literal52);
                    		adaptor.AddChild(root_0, string_literal52_tree);
                    	}
                    	string_literal53=(IToken)Match(input,54,FOLLOW_54_in_func_declaration_specifiers574); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal53_tree = (CommonTree)adaptor.Create(string_literal53);
                    		adaptor.AddChild(root_0, string_literal53_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("ref string");
                    	}

                    }
                    break;
                case 10 :
                    // GxcGrammer\\Gxc.g:138:4: 'var' type_id
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal54=(IToken)Match(input,55,FOLLOW_55_in_func_declaration_specifiers581); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal54_tree = (CommonTree)adaptor.Create(string_literal54);
                    		adaptor.AddChild(root_0, string_literal54_tree);
                    	}
                    	PushFollow(FOLLOW_type_id_in_func_declaration_specifiers583);
                    	type_id55 = type_id();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_id55.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((function_declaration_scope)function_declaration_stack.Peek()).argTypes.Add("ref "+ input.LT(-1).Text);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 10, func_declaration_specifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "func_declaration_specifiers"

    public class dll_specifier_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "dll_specifier"
    // GxcGrammer\\Gxc.g:141:1: dll_specifier : '[' IDENTIFIER ']' ;
    public GxcParser.dll_specifier_return dll_specifier() // throws RecognitionException [1]
    {   
        GxcParser.dll_specifier_return retval = new GxcParser.dll_specifier_return();
        retval.Start = input.LT(1);
        int dll_specifier_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal56 = null;
        IToken IDENTIFIER57 = null;
        IToken char_literal58 = null;

        CommonTree char_literal56_tree=null;
        CommonTree IDENTIFIER57_tree=null;
        CommonTree char_literal58_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 11) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:142:4: ( '[' IDENTIFIER ']' )
            // GxcGrammer\\Gxc.g:142:5: '[' IDENTIFIER ']'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	char_literal56=(IToken)Match(input,56,FOLLOW_56_in_dll_specifier598); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal56_tree = (CommonTree)adaptor.Create(char_literal56);
            		adaptor.AddChild(root_0, char_literal56_tree);
            	}
            	IDENTIFIER57=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_dll_specifier600); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{IDENTIFIER57_tree = (CommonTree)adaptor.Create(IDENTIFIER57);
            		adaptor.AddChild(root_0, IDENTIFIER57_tree);
            	}
            	char_literal58=(IToken)Match(input,57,FOLLOW_57_in_dll_specifier602); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal58_tree = (CommonTree)adaptor.Create(char_literal58);
            		adaptor.AddChild(root_0, char_literal58_tree);
            	}
            	if ( (state.backtracking==0) )
            	{
            	  ((function_declaration_scope)function_declaration_stack.Peek()).dll = IDENTIFIER57.Text;
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 11, dll_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "dll_specifier"

    public class func_declaration_arugments_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "func_declaration_arugments"
    // GxcGrammer\\Gxc.g:145:1: func_declaration_arugments : func_declaration_specifiers ( ',' func_declaration_specifiers )* ;
    public GxcParser.func_declaration_arugments_return func_declaration_arugments() // throws RecognitionException [1]
    {   
        GxcParser.func_declaration_arugments_return retval = new GxcParser.func_declaration_arugments_return();
        retval.Start = input.LT(1);
        int func_declaration_arugments_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal60 = null;
        GxcParser.func_declaration_specifiers_return func_declaration_specifiers59 = default(GxcParser.func_declaration_specifiers_return);

        GxcParser.func_declaration_specifiers_return func_declaration_specifiers61 = default(GxcParser.func_declaration_specifiers_return);


        CommonTree char_literal60_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 12) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:146:4: ( func_declaration_specifiers ( ',' func_declaration_specifiers )* )
            // GxcGrammer\\Gxc.g:146:5: func_declaration_specifiers ( ',' func_declaration_specifiers )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_func_declaration_specifiers_in_func_declaration_arugments618);
            	func_declaration_specifiers59 = func_declaration_specifiers();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, func_declaration_specifiers59.Tree);
            	// GxcGrammer\\Gxc.g:146:33: ( ',' func_declaration_specifiers )*
            	do 
            	{
            	    int alt11 = 2;
            	    alt11 = dfa11.Predict(input);
            	    switch (alt11) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:146:34: ',' func_declaration_specifiers
            			    {
            			    	char_literal60=(IToken)Match(input,47,FOLLOW_47_in_func_declaration_arugments621); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal60_tree = (CommonTree)adaptor.Create(char_literal60);
            			    		adaptor.AddChild(root_0, char_literal60_tree);
            			    	}
            			    	PushFollow(FOLLOW_func_declaration_specifiers_in_func_declaration_arugments623);
            			    	func_declaration_specifiers61 = func_declaration_specifiers();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, func_declaration_specifiers61.Tree);

            			    }
            			    break;

            			default:
            			    goto loop11;
            	    }
            	} while (true);

            	loop11:
            		;	// Stops C# compiler whining that label 'loop11' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 12, func_declaration_arugments_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "func_declaration_arugments"

    public class variable_type_specifier_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "variable_type_specifier"
    // GxcGrammer\\Gxc.g:148:1: variable_type_specifier : ( 'void' | 'int' ( '(' DECIMAL_LITERAL ')' )* | 'real' ( '(' DECIMAL_LITERAL ')' )* | 'string' ( '(' DECIMAL_LITERAL ')' )* | type_id );
    public GxcParser.variable_type_specifier_return variable_type_specifier() // throws RecognitionException [1]
    {   
        GxcParser.variable_type_specifier_return retval = new GxcParser.variable_type_specifier_return();
        retval.Start = input.LT(1);
        int variable_type_specifier_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal62 = null;
        IToken string_literal63 = null;
        IToken char_literal64 = null;
        IToken DECIMAL_LITERAL65 = null;
        IToken char_literal66 = null;
        IToken string_literal67 = null;
        IToken char_literal68 = null;
        IToken DECIMAL_LITERAL69 = null;
        IToken char_literal70 = null;
        IToken string_literal71 = null;
        IToken char_literal72 = null;
        IToken DECIMAL_LITERAL73 = null;
        IToken char_literal74 = null;
        GxcParser.type_id_return type_id75 = default(GxcParser.type_id_return);


        CommonTree string_literal62_tree=null;
        CommonTree string_literal63_tree=null;
        CommonTree char_literal64_tree=null;
        CommonTree DECIMAL_LITERAL65_tree=null;
        CommonTree char_literal66_tree=null;
        CommonTree string_literal67_tree=null;
        CommonTree char_literal68_tree=null;
        CommonTree DECIMAL_LITERAL69_tree=null;
        CommonTree char_literal70_tree=null;
        CommonTree string_literal71_tree=null;
        CommonTree char_literal72_tree=null;
        CommonTree DECIMAL_LITERAL73_tree=null;
        CommonTree char_literal74_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:149:2: ( 'void' | 'int' ( '(' DECIMAL_LITERAL ')' )* | 'real' ( '(' DECIMAL_LITERAL ')' )* | 'string' ( '(' DECIMAL_LITERAL ')' )* | type_id )
            int alt15 = 5;
            switch ( input.LA(1) ) 
            {
            case 51:
            	{
                alt15 = 1;
                }
                break;
            case 52:
            	{
                alt15 = 2;
                }
                break;
            case 53:
            	{
                alt15 = 3;
                }
                break;
            case 54:
            	{
                alt15 = 4;
                }
                break;
            case IDENTIFIER:
            	{
                alt15 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d15s0 =
            	        new NoViableAltException("", 15, 0, input);

            	    throw nvae_d15s0;
            }

            switch (alt15) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:149:4: 'void'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal62=(IToken)Match(input,51,FOLLOW_51_in_variable_type_specifier637); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal62_tree = (CommonTree)adaptor.Create(string_literal62);
                    		adaptor.AddChild(root_0, string_literal62_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).type = "void";
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:150:4: 'int' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal63=(IToken)Match(input,52,FOLLOW_52_in_variable_type_specifier644); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal63_tree = (CommonTree)adaptor.Create(string_literal63);
                    		adaptor.AddChild(root_0, string_literal63_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:150:11: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt12 = 2;
                    	    int LA12_0 = input.LA(1);

                    	    if ( (LA12_0 == 49) )
                    	    {
                    	        alt12 = 1;
                    	    }


                    	    switch (alt12) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:150:14: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal64=(IToken)Match(input,49,FOLLOW_49_in_variable_type_specifier650); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL65=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier653); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL65_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL65);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL65_tree);
                    			    	}
                    			    	if ( (state.backtracking==0) )
                    			    	{
                    			    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).size = int.Parse(DECIMAL_LITERAL65.Text);
                    			    	}
                    			    	char_literal66=(IToken)Match(input,50,FOLLOW_50_in_variable_type_specifier656); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop12;
                    	    }
                    	} while (true);

                    	loop12:
                    		;	// Stops C# compiler whining that label 'loop12' has no statements

                    	if ( (state.backtracking==0) )
                    	{
                    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).type = "int";
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:151:4: 'real' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal67=(IToken)Match(input,53,FOLLOW_53_in_variable_type_specifier667); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal67_tree = (CommonTree)adaptor.Create(string_literal67);
                    		adaptor.AddChild(root_0, string_literal67_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:151:11: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt13 = 2;
                    	    int LA13_0 = input.LA(1);

                    	    if ( (LA13_0 == 49) )
                    	    {
                    	        alt13 = 1;
                    	    }


                    	    switch (alt13) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:151:14: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal68=(IToken)Match(input,49,FOLLOW_49_in_variable_type_specifier672); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL69=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier675); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL69_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL69);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL69_tree);
                    			    	}
                    			    	if ( (state.backtracking==0) )
                    			    	{
                    			    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).size = int.Parse(DECIMAL_LITERAL69.Text);
                    			    	}
                    			    	char_literal70=(IToken)Match(input,50,FOLLOW_50_in_variable_type_specifier678); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop13;
                    	    }
                    	} while (true);

                    	loop13:
                    		;	// Stops C# compiler whining that label 'loop13' has no statements

                    	if ( (state.backtracking==0) )
                    	{
                    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).type = "real";
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:152:4: 'string' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal71=(IToken)Match(input,54,FOLLOW_54_in_variable_type_specifier690); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal71_tree = (CommonTree)adaptor.Create(string_literal71);
                    		adaptor.AddChild(root_0, string_literal71_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:152:14: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt14 = 2;
                    	    int LA14_0 = input.LA(1);

                    	    if ( (LA14_0 == 49) )
                    	    {
                    	        alt14 = 1;
                    	    }


                    	    switch (alt14) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:152:17: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal72=(IToken)Match(input,49,FOLLOW_49_in_variable_type_specifier696); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL73=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier699); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL73_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL73);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL73_tree);
                    			    	}
                    			    	if ( (state.backtracking==0) )
                    			    	{
                    			    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).size = int.Parse(DECIMAL_LITERAL73.Text);
                    			    	}
                    			    	char_literal74=(IToken)Match(input,50,FOLLOW_50_in_variable_type_specifier703); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop14;
                    	    }
                    	} while (true);

                    	loop14:
                    		;	// Stops C# compiler whining that label 'loop14' has no statements

                    	if ( (state.backtracking==0) )
                    	{
                    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).type = "string";
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:153:4: type_id
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_id_in_variable_type_specifier715);
                    	type_id75 = type_id();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_id75.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  ((variable_declaration_scope)variable_declaration_stack.Peek()).type = "string";
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 13, variable_type_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_type_specifier"

    public class type_specifier_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "type_specifier"
    // GxcGrammer\\Gxc.g:156:1: type_specifier : ( 'void' | 'int' ( '(' DECIMAL_LITERAL ')' )* | 'real' ( '(' DECIMAL_LITERAL ')' )* | 'string' ( '(' DECIMAL_LITERAL ')' )* | type_id );
    public GxcParser.type_specifier_return type_specifier() // throws RecognitionException [1]
    {   
        GxcParser.type_specifier_return retval = new GxcParser.type_specifier_return();
        retval.Start = input.LT(1);
        int type_specifier_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal76 = null;
        IToken string_literal77 = null;
        IToken char_literal78 = null;
        IToken DECIMAL_LITERAL79 = null;
        IToken char_literal80 = null;
        IToken string_literal81 = null;
        IToken char_literal82 = null;
        IToken DECIMAL_LITERAL83 = null;
        IToken char_literal84 = null;
        IToken string_literal85 = null;
        IToken char_literal86 = null;
        IToken DECIMAL_LITERAL87 = null;
        IToken char_literal88 = null;
        GxcParser.type_id_return type_id89 = default(GxcParser.type_id_return);


        CommonTree string_literal76_tree=null;
        CommonTree string_literal77_tree=null;
        CommonTree char_literal78_tree=null;
        CommonTree DECIMAL_LITERAL79_tree=null;
        CommonTree char_literal80_tree=null;
        CommonTree string_literal81_tree=null;
        CommonTree char_literal82_tree=null;
        CommonTree DECIMAL_LITERAL83_tree=null;
        CommonTree char_literal84_tree=null;
        CommonTree string_literal85_tree=null;
        CommonTree char_literal86_tree=null;
        CommonTree DECIMAL_LITERAL87_tree=null;
        CommonTree char_literal88_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 14) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:157:2: ( 'void' | 'int' ( '(' DECIMAL_LITERAL ')' )* | 'real' ( '(' DECIMAL_LITERAL ')' )* | 'string' ( '(' DECIMAL_LITERAL ')' )* | type_id )
            int alt19 = 5;
            switch ( input.LA(1) ) 
            {
            case 51:
            	{
                alt19 = 1;
                }
                break;
            case 52:
            	{
                alt19 = 2;
                }
                break;
            case 53:
            	{
                alt19 = 3;
                }
                break;
            case 54:
            	{
                alt19 = 4;
                }
                break;
            case IDENTIFIER:
            	{
                alt19 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d19s0 =
            	        new NoViableAltException("", 19, 0, input);

            	    throw nvae_d19s0;
            }

            switch (alt19) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:157:4: 'void'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal76=(IToken)Match(input,51,FOLLOW_51_in_type_specifier730); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal76_tree = (CommonTree)adaptor.Create(string_literal76);
                    		adaptor.AddChild(root_0, string_literal76_tree);
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:158:4: 'int' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal77=(IToken)Match(input,52,FOLLOW_52_in_type_specifier736); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal77_tree = (CommonTree)adaptor.Create(string_literal77);
                    		adaptor.AddChild(root_0, string_literal77_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:158:11: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt16 = 2;
                    	    int LA16_0 = input.LA(1);

                    	    if ( (LA16_0 == 49) )
                    	    {
                    	        alt16 = 1;
                    	    }


                    	    switch (alt16) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:158:14: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal78=(IToken)Match(input,49,FOLLOW_49_in_type_specifier742); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL79=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_type_specifier745); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL79_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL79);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL79_tree);
                    			    	}
                    			    	char_literal80=(IToken)Match(input,50,FOLLOW_50_in_type_specifier746); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop16;
                    	    }
                    	} while (true);

                    	loop16:
                    		;	// Stops C# compiler whining that label 'loop16' has no statements


                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:159:4: 'real' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal81=(IToken)Match(input,53,FOLLOW_53_in_type_specifier756); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal81_tree = (CommonTree)adaptor.Create(string_literal81);
                    		adaptor.AddChild(root_0, string_literal81_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:159:11: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt17 = 2;
                    	    int LA17_0 = input.LA(1);

                    	    if ( (LA17_0 == 49) )
                    	    {
                    	        alt17 = 1;
                    	    }


                    	    switch (alt17) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:159:14: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal82=(IToken)Match(input,49,FOLLOW_49_in_type_specifier761); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL83=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_type_specifier764); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL83_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL83);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL83_tree);
                    			    	}
                    			    	char_literal84=(IToken)Match(input,50,FOLLOW_50_in_type_specifier766); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop17;
                    	    }
                    	} while (true);

                    	loop17:
                    		;	// Stops C# compiler whining that label 'loop17' has no statements


                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:160:4: 'string' ( '(' DECIMAL_LITERAL ')' )*
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal85=(IToken)Match(input,54,FOLLOW_54_in_type_specifier777); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal85_tree = (CommonTree)adaptor.Create(string_literal85);
                    		adaptor.AddChild(root_0, string_literal85_tree);
                    	}
                    	// GxcGrammer\\Gxc.g:160:14: ( '(' DECIMAL_LITERAL ')' )*
                    	do 
                    	{
                    	    int alt18 = 2;
                    	    int LA18_0 = input.LA(1);

                    	    if ( (LA18_0 == 49) )
                    	    {
                    	        alt18 = 1;
                    	    }


                    	    switch (alt18) 
                    		{
                    			case 1 :
                    			    // GxcGrammer\\Gxc.g:160:17: '(' DECIMAL_LITERAL ')'
                    			    {
                    			    	char_literal86=(IToken)Match(input,49,FOLLOW_49_in_type_specifier783); if (state.failed) return retval;
                    			    	DECIMAL_LITERAL87=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_type_specifier786); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DECIMAL_LITERAL87_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL87);
                    			    		adaptor.AddChild(root_0, DECIMAL_LITERAL87_tree);
                    			    	}
                    			    	char_literal88=(IToken)Match(input,50,FOLLOW_50_in_type_specifier788); if (state.failed) return retval;

                    			    }
                    			    break;

                    			default:
                    			    goto loop18;
                    	    }
                    	} while (true);

                    	loop18:
                    		;	// Stops C# compiler whining that label 'loop18' has no statements


                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:161:4: type_id
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_id_in_type_specifier799);
                    	type_id89 = type_id();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_id89.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 14, type_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_specifier"

    public class type_id_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "type_id"
    // GxcGrammer\\Gxc.g:165:1: type_id : {...}? IDENTIFIER ;
    public GxcParser.type_id_return type_id() // throws RecognitionException [1]
    {   
        GxcParser.type_id_return retval = new GxcParser.type_id_return();
        retval.Start = input.LT(1);
        int type_id_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IDENTIFIER90 = null;

        CommonTree IDENTIFIER90_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 15) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:166:5: ({...}? IDENTIFIER )
            // GxcGrammer\\Gxc.g:166:9: {...}? IDENTIFIER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	if ( !((isTypeName(input.LT(1).Text))) ) 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    throw new FailedPredicateException(input, "type_id", "isTypeName(input.LT(1).Text)");
            	}
            	IDENTIFIER90=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_type_id820); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{IDENTIFIER90_tree = (CommonTree)adaptor.Create(IDENTIFIER90);
            		adaptor.AddChild(root_0, IDENTIFIER90_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 15, type_id_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_id"

    public class identifier_list_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "identifier_list"
    // GxcGrammer\\Gxc.g:172:1: identifier_list : identifier ( ',' identifier )* ;
    public GxcParser.identifier_list_return identifier_list() // throws RecognitionException [1]
    {   
        GxcParser.identifier_list_return retval = new GxcParser.identifier_list_return();
        retval.Start = input.LT(1);
        int identifier_list_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal92 = null;
        GxcParser.identifier_return identifier91 = default(GxcParser.identifier_return);

        GxcParser.identifier_return identifier93 = default(GxcParser.identifier_return);


        CommonTree char_literal92_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 16) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:173:2: ( identifier ( ',' identifier )* )
            // GxcGrammer\\Gxc.g:173:4: identifier ( ',' identifier )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_identifier_list837);
            	identifier91 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier91.Tree);
            	// GxcGrammer\\Gxc.g:173:16: ( ',' identifier )*
            	do 
            	{
            	    int alt20 = 2;
            	    int LA20_0 = input.LA(1);

            	    if ( (LA20_0 == 47) )
            	    {
            	        alt20 = 1;
            	    }


            	    switch (alt20) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:173:17: ',' identifier
            			    {
            			    	char_literal92=(IToken)Match(input,47,FOLLOW_47_in_identifier_list841); if (state.failed) return retval;
            			    	PushFollow(FOLLOW_identifier_in_identifier_list844);
            			    	identifier93 = identifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier93.Tree);

            			    }
            			    break;

            			default:
            			    goto loop20;
            	    }
            	} while (true);

            	loop20:
            		;	// Stops C# compiler whining that label 'loop20' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 16, identifier_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "identifier_list"

    public class identifier_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "identifier"
    // GxcGrammer\\Gxc.g:175:1: identifier : IDENTIFIER ;
    public GxcParser.identifier_return identifier() // throws RecognitionException [1]
    {   
        GxcParser.identifier_return retval = new GxcParser.identifier_return();
        retval.Start = input.LT(1);
        int identifier_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IDENTIFIER94 = null;

        CommonTree IDENTIFIER94_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 17) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:177:4: ( IDENTIFIER )
            // GxcGrammer\\Gxc.g:177:6: IDENTIFIER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	IDENTIFIER94=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier862); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{IDENTIFIER94_tree = (CommonTree)adaptor.Create(IDENTIFIER94);
            		adaptor.AddChild(root_0, IDENTIFIER94_tree);
            	}
            	if ( (state.backtracking==0) )
            	{

            	                        ((variable_declaration_scope)variable_declaration_stack.Peek()).variables.Add(IDENTIFIER94.Text);
            	                  
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 17, identifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "identifier"

    public class argument_expression_list_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "argument_expression_list"
    // GxcGrammer\\Gxc.g:188:1: argument_expression_list : assignment_expression ( ',' assignment_expression )* ;
    public GxcParser.argument_expression_list_return argument_expression_list() // throws RecognitionException [1]
    {   
        GxcParser.argument_expression_list_return retval = new GxcParser.argument_expression_list_return();
        retval.Start = input.LT(1);
        int argument_expression_list_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal96 = null;
        GxcParser.assignment_expression_return assignment_expression95 = default(GxcParser.assignment_expression_return);

        GxcParser.assignment_expression_return assignment_expression97 = default(GxcParser.assignment_expression_return);


        CommonTree char_literal96_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 18) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:189:2: ( assignment_expression ( ',' assignment_expression )* )
            // GxcGrammer\\Gxc.g:189:6: assignment_expression ( ',' assignment_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_assignment_expression_in_argument_expression_list887);
            	assignment_expression95 = assignment_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_expression95.Tree);
            	// GxcGrammer\\Gxc.g:189:28: ( ',' assignment_expression )*
            	do 
            	{
            	    int alt21 = 2;
            	    int LA21_0 = input.LA(1);

            	    if ( (LA21_0 == 47) )
            	    {
            	        alt21 = 1;
            	    }


            	    switch (alt21) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:189:29: ',' assignment_expression
            			    {
            			    	char_literal96=(IToken)Match(input,47,FOLLOW_47_in_argument_expression_list890); if (state.failed) return retval;
            			    	PushFollow(FOLLOW_assignment_expression_in_argument_expression_list893);
            			    	assignment_expression97 = assignment_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_expression97.Tree);

            			    }
            			    break;

            			default:
            			    goto loop21;
            	    }
            	} while (true);

            	loop21:
            		;	// Stops C# compiler whining that label 'loop21' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 18, argument_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argument_expression_list"

    public class additive_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "additive_expression"
    // GxcGrammer\\Gxc.g:192:1: additive_expression : ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* ;
    public GxcParser.additive_expression_return additive_expression() // throws RecognitionException [1]
    {   
        GxcParser.additive_expression_return retval = new GxcParser.additive_expression_return();
        retval.Start = input.LT(1);
        int additive_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal99 = null;
        IToken char_literal101 = null;
        GxcParser.multiplicative_expression_return multiplicative_expression98 = default(GxcParser.multiplicative_expression_return);

        GxcParser.multiplicative_expression_return multiplicative_expression100 = default(GxcParser.multiplicative_expression_return);

        GxcParser.multiplicative_expression_return multiplicative_expression102 = default(GxcParser.multiplicative_expression_return);


        CommonTree char_literal99_tree=null;
        CommonTree char_literal101_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 19) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:193:2: ( ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* )
            // GxcGrammer\\Gxc.g:193:4: ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// GxcGrammer\\Gxc.g:193:4: ( multiplicative_expression )
            	// GxcGrammer\\Gxc.g:193:5: multiplicative_expression
            	{
            		PushFollow(FOLLOW_multiplicative_expression_in_additive_expression907);
            		multiplicative_expression98 = multiplicative_expression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression98.Tree);

            	}

            	// GxcGrammer\\Gxc.g:193:32: ( '+' multiplicative_expression | '-' multiplicative_expression )*
            	do 
            	{
            	    int alt22 = 3;
            	    alt22 = dfa22.Predict(input);
            	    switch (alt22) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:193:33: '+' multiplicative_expression
            			    {
            			    	char_literal99=(IToken)Match(input,58,FOLLOW_58_in_additive_expression911); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal99_tree = (CommonTree)adaptor.Create(char_literal99);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal99_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_multiplicative_expression_in_additive_expression914);
            			    	multiplicative_expression100 = multiplicative_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression100.Tree);

            			    }
            			    break;
            			case 2 :
            			    // GxcGrammer\\Gxc.g:193:66: '-' multiplicative_expression
            			    {
            			    	char_literal101=(IToken)Match(input,59,FOLLOW_59_in_additive_expression918); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal101_tree = (CommonTree)adaptor.Create(char_literal101);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal101_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_multiplicative_expression_in_additive_expression921);
            			    	multiplicative_expression102 = multiplicative_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression102.Tree);

            			    }
            			    break;

            			default:
            			    goto loop22;
            	    }
            	} while (true);

            	loop22:
            		;	// Stops C# compiler whining that label 'loop22' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 19, additive_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "additive_expression"

    public class multiplicative_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "multiplicative_expression"
    // GxcGrammer\\Gxc.g:196:1: multiplicative_expression : ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* ;
    public GxcParser.multiplicative_expression_return multiplicative_expression() // throws RecognitionException [1]
    {   
        GxcParser.multiplicative_expression_return retval = new GxcParser.multiplicative_expression_return();
        retval.Start = input.LT(1);
        int multiplicative_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal104 = null;
        IToken char_literal106 = null;
        IToken char_literal108 = null;
        GxcParser.cast_expression_return cast_expression103 = default(GxcParser.cast_expression_return);

        GxcParser.cast_expression_return cast_expression105 = default(GxcParser.cast_expression_return);

        GxcParser.cast_expression_return cast_expression107 = default(GxcParser.cast_expression_return);

        GxcParser.cast_expression_return cast_expression109 = default(GxcParser.cast_expression_return);


        CommonTree char_literal104_tree=null;
        CommonTree char_literal106_tree=null;
        CommonTree char_literal108_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 20) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:197:2: ( ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* )
            // GxcGrammer\\Gxc.g:197:4: ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// GxcGrammer\\Gxc.g:197:4: ( cast_expression )
            	// GxcGrammer\\Gxc.g:197:5: cast_expression
            	{
            		PushFollow(FOLLOW_cast_expression_in_multiplicative_expression935);
            		cast_expression103 = cast_expression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression103.Tree);

            	}

            	// GxcGrammer\\Gxc.g:197:22: ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
            	do 
            	{
            	    int alt23 = 4;
            	    alt23 = dfa23.Predict(input);
            	    switch (alt23) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:197:23: '*' cast_expression
            			    {
            			    	char_literal104=(IToken)Match(input,60,FOLLOW_60_in_multiplicative_expression939); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal104_tree = (CommonTree)adaptor.Create(char_literal104);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal104_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_cast_expression_in_multiplicative_expression942);
            			    	cast_expression105 = cast_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression105.Tree);

            			    }
            			    break;
            			case 2 :
            			    // GxcGrammer\\Gxc.g:197:46: '/' cast_expression
            			    {
            			    	char_literal106=(IToken)Match(input,61,FOLLOW_61_in_multiplicative_expression946); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal106_tree = (CommonTree)adaptor.Create(char_literal106);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal106_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_cast_expression_in_multiplicative_expression949);
            			    	cast_expression107 = cast_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression107.Tree);

            			    }
            			    break;
            			case 3 :
            			    // GxcGrammer\\Gxc.g:197:69: '%' cast_expression
            			    {
            			    	char_literal108=(IToken)Match(input,62,FOLLOW_62_in_multiplicative_expression953); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal108_tree = (CommonTree)adaptor.Create(char_literal108);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal108_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_cast_expression_in_multiplicative_expression956);
            			    	cast_expression109 = cast_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression109.Tree);

            			    }
            			    break;

            			default:
            			    goto loop23;
            	    }
            	} while (true);

            	loop23:
            		;	// Stops C# compiler whining that label 'loop23' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 20, multiplicative_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "multiplicative_expression"

    public class cast_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "cast_expression"
    // GxcGrammer\\Gxc.g:200:1: cast_expression : ( '(' type_specifier ')' cast_expression | unary_expression );
    public GxcParser.cast_expression_return cast_expression() // throws RecognitionException [1]
    {   
        GxcParser.cast_expression_return retval = new GxcParser.cast_expression_return();
        retval.Start = input.LT(1);
        int cast_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal110 = null;
        IToken char_literal112 = null;
        GxcParser.type_specifier_return type_specifier111 = default(GxcParser.type_specifier_return);

        GxcParser.cast_expression_return cast_expression113 = default(GxcParser.cast_expression_return);

        GxcParser.unary_expression_return unary_expression114 = default(GxcParser.unary_expression_return);


        CommonTree char_literal110_tree=null;
        CommonTree char_literal112_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 21) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:201:2: ( '(' type_specifier ')' cast_expression | unary_expression )
            int alt24 = 2;
            alt24 = dfa24.Predict(input);
            switch (alt24) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:201:4: '(' type_specifier ')' cast_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal110=(IToken)Match(input,49,FOLLOW_49_in_cast_expression969); if (state.failed) return retval;
                    	PushFollow(FOLLOW_type_specifier_in_cast_expression972);
                    	type_specifier111 = type_specifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_specifier111.Tree);
                    	char_literal112=(IToken)Match(input,50,FOLLOW_50_in_cast_expression974); if (state.failed) return retval;
                    	PushFollow(FOLLOW_cast_expression_in_cast_expression977);
                    	cast_expression113 = cast_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression113.Tree);

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:202:4: unary_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unary_expression_in_cast_expression982);
                    	unary_expression114 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression114.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 21, cast_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "cast_expression"

    public class unary_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "unary_expression"
    // GxcGrammer\\Gxc.g:205:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_specifier ')' );
    public GxcParser.unary_expression_return unary_expression() // throws RecognitionException [1]
    {   
        GxcParser.unary_expression_return retval = new GxcParser.unary_expression_return();
        retval.Start = input.LT(1);
        int unary_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal116 = null;
        IToken string_literal118 = null;
        IToken string_literal122 = null;
        IToken string_literal124 = null;
        IToken char_literal125 = null;
        IToken char_literal127 = null;
        GxcParser.postfix_expression_return postfix_expression115 = default(GxcParser.postfix_expression_return);

        GxcParser.unary_expression_return unary_expression117 = default(GxcParser.unary_expression_return);

        GxcParser.unary_expression_return unary_expression119 = default(GxcParser.unary_expression_return);

        GxcParser.unary_operator_return unary_operator120 = default(GxcParser.unary_operator_return);

        GxcParser.cast_expression_return cast_expression121 = default(GxcParser.cast_expression_return);

        GxcParser.unary_expression_return unary_expression123 = default(GxcParser.unary_expression_return);

        GxcParser.type_specifier_return type_specifier126 = default(GxcParser.type_specifier_return);


        CommonTree string_literal116_tree=null;
        CommonTree string_literal118_tree=null;
        CommonTree string_literal122_tree=null;
        CommonTree string_literal124_tree=null;
        CommonTree char_literal125_tree=null;
        CommonTree char_literal127_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 22) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:206:2: ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_specifier ')' )
            int alt25 = 6;
            alt25 = dfa25.Predict(input);
            switch (alt25) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:206:4: postfix_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_postfix_expression_in_unary_expression993);
                    	postfix_expression115 = postfix_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, postfix_expression115.Tree);

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:207:4: '++' unary_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal116=(IToken)Match(input,63,FOLLOW_63_in_unary_expression998); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal116_tree = (CommonTree)adaptor.Create(string_literal116);
                    		adaptor.AddChild(root_0, string_literal116_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("_++");
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression1001);
                    	unary_expression117 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression117.Tree);

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:208:4: '--' unary_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal118=(IToken)Match(input,64,FOLLOW_64_in_unary_expression1006); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal118_tree = (CommonTree)adaptor.Create(string_literal118);
                    		adaptor.AddChild(root_0, string_literal118_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("_--");
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression1009);
                    	unary_expression119 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression119.Tree);

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:209:4: unary_operator cast_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unary_operator_in_unary_expression1014);
                    	unary_operator120 = unary_operator();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_operator120.Tree);
                    	PushFollow(FOLLOW_cast_expression_in_unary_expression1016);
                    	cast_expression121 = cast_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression121.Tree);

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:210:4: 'sizeof' unary_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal122=(IToken)Match(input,65,FOLLOW_65_in_unary_expression1021); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal122_tree = (CommonTree)adaptor.Create(string_literal122);
                    		adaptor.AddChild(root_0, string_literal122_tree);
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression1023);
                    	unary_expression123 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression123.Tree);

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:211:4: 'sizeof' '(' type_specifier ')'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal124=(IToken)Match(input,65,FOLLOW_65_in_unary_expression1028); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal124_tree = (CommonTree)adaptor.Create(string_literal124);
                    		adaptor.AddChild(root_0, string_literal124_tree);
                    	}
                    	char_literal125=(IToken)Match(input,49,FOLLOW_49_in_unary_expression1030); if (state.failed) return retval;
                    	PushFollow(FOLLOW_type_specifier_in_unary_expression1033);
                    	type_specifier126 = type_specifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_specifier126.Tree);
                    	char_literal127=(IToken)Match(input,50,FOLLOW_50_in_unary_expression1035); if (state.failed) return retval;

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 22, unary_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unary_expression"

    public class postfix_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "postfix_expression"
    // GxcGrammer\\Gxc.g:214:1: postfix_expression : ( primary_expression -> ^( VARIABLE primary_expression ) | primary_expression '[' expression ']' | primary_expression '++' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_INCREMENT ) | primary_expression '--' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_DECREMENT ) | primary_expression '(' ( argument_expression_list )? ')' -> ^( FUNCTION_CALL ^( primary_expression ( argument_expression_list )? ) ) );
    public GxcParser.postfix_expression_return postfix_expression() // throws RecognitionException [1]
    {   
        GxcParser.postfix_expression_return retval = new GxcParser.postfix_expression_return();
        retval.Start = input.LT(1);
        int postfix_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal130 = null;
        IToken char_literal132 = null;
        IToken string_literal134 = null;
        IToken string_literal136 = null;
        IToken char_literal138 = null;
        IToken char_literal140 = null;
        GxcParser.primary_expression_return primary_expression128 = default(GxcParser.primary_expression_return);

        GxcParser.primary_expression_return primary_expression129 = default(GxcParser.primary_expression_return);

        GxcParser.expression_return expression131 = default(GxcParser.expression_return);

        GxcParser.primary_expression_return primary_expression133 = default(GxcParser.primary_expression_return);

        GxcParser.primary_expression_return primary_expression135 = default(GxcParser.primary_expression_return);

        GxcParser.primary_expression_return primary_expression137 = default(GxcParser.primary_expression_return);

        GxcParser.argument_expression_list_return argument_expression_list139 = default(GxcParser.argument_expression_list_return);


        CommonTree char_literal130_tree=null;
        CommonTree char_literal132_tree=null;
        CommonTree string_literal134_tree=null;
        CommonTree string_literal136_tree=null;
        CommonTree char_literal138_tree=null;
        CommonTree char_literal140_tree=null;
        RewriteRuleTokenStream stream_49 = new RewriteRuleTokenStream(adaptor,"token 49");
        RewriteRuleTokenStream stream_64 = new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleTokenStream stream_63 = new RewriteRuleTokenStream(adaptor,"token 63");
        RewriteRuleTokenStream stream_50 = new RewriteRuleTokenStream(adaptor,"token 50");
        RewriteRuleSubtreeStream stream_primary_expression = new RewriteRuleSubtreeStream(adaptor,"rule primary_expression");
        RewriteRuleSubtreeStream stream_argument_expression_list = new RewriteRuleSubtreeStream(adaptor,"rule argument_expression_list");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 23) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:215:2: ( primary_expression -> ^( VARIABLE primary_expression ) | primary_expression '[' expression ']' | primary_expression '++' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_INCREMENT ) | primary_expression '--' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_DECREMENT ) | primary_expression '(' ( argument_expression_list )? ')' -> ^( FUNCTION_CALL ^( primary_expression ( argument_expression_list )? ) ) )
            int alt27 = 5;
            alt27 = dfa27.Predict(input);
            switch (alt27) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:215:4: primary_expression
                    {
                    	PushFollow(FOLLOW_primary_expression_in_postfix_expression1047);
                    	primary_expression128 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primary_expression.Add(primary_expression128.Tree);


                    	// AST REWRITE
                    	// elements:          primary_expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 215:23: -> ^( VARIABLE primary_expression )
                    	{
                    	    // GxcGrammer\\Gxc.g:215:26: ^( VARIABLE primary_expression )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VARIABLE, "VARIABLE"), root_1);

                    	    adaptor.AddChild(root_1, stream_primary_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:216:4: primary_expression '[' expression ']'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primary_expression_in_postfix_expression1060);
                    	primary_expression129 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression129.Tree);
                    	char_literal130=(IToken)Match(input,56,FOLLOW_56_in_postfix_expression1062); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal130_tree = (CommonTree)adaptor.Create(char_literal130);
                    		adaptor.AddChild(root_0, char_literal130_tree);
                    	}
                    	PushFollow(FOLLOW_expression_in_postfix_expression1064);
                    	expression131 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression131.Tree);
                    	char_literal132=(IToken)Match(input,57,FOLLOW_57_in_postfix_expression1066); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal132_tree = (CommonTree)adaptor.Create(char_literal132);
                    		adaptor.AddChild(root_0, char_literal132_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("[]");
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:217:4: primary_expression '++'
                    {
                    	PushFollow(FOLLOW_primary_expression_in_postfix_expression1073);
                    	primary_expression133 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primary_expression.Add(primary_expression133.Tree);
                    	string_literal134=(IToken)Match(input,63,FOLLOW_63_in_postfix_expression1075); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_63.Add(string_literal134);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("++");
                    	}


                    	// AST REWRITE
                    	// elements:          primary_expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 217:59: -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_INCREMENT )
                    	{
                    	    // GxcGrammer\\Gxc.g:217:62: ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_INCREMENT )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ASSIGNMENT, "ASSIGNMENT"), root_1);

                    	    // GxcGrammer\\Gxc.g:217:75: ^( VARIABLE primary_expression )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VARIABLE, "VARIABLE"), root_2);

                    	    adaptor.AddChild(root_2, stream_primary_expression.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, (CommonTree)adaptor.Create(UNARY_INCREMENT, "UNARY_INCREMENT"));

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:218:4: primary_expression '--'
                    {
                    	PushFollow(FOLLOW_primary_expression_in_postfix_expression1095);
                    	primary_expression135 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primary_expression.Add(primary_expression135.Tree);
                    	string_literal136=(IToken)Match(input,64,FOLLOW_64_in_postfix_expression1097); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_64.Add(string_literal136);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("--");
                    	}


                    	// AST REWRITE
                    	// elements:          primary_expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 218:60: -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_DECREMENT )
                    	{
                    	    // GxcGrammer\\Gxc.g:218:63: ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_DECREMENT )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ASSIGNMENT, "ASSIGNMENT"), root_1);

                    	    // GxcGrammer\\Gxc.g:218:76: ^( VARIABLE primary_expression )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VARIABLE, "VARIABLE"), root_2);

                    	    adaptor.AddChild(root_2, stream_primary_expression.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, (CommonTree)adaptor.Create(UNARY_DECREMENT, "UNARY_DECREMENT"));

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:219:6: primary_expression '(' ( argument_expression_list )? ')'
                    {
                    	PushFollow(FOLLOW_primary_expression_in_postfix_expression1120);
                    	primary_expression137 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primary_expression.Add(primary_expression137.Tree);
                    	char_literal138=(IToken)Match(input,49,FOLLOW_49_in_postfix_expression1122); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal138);

                    	// GxcGrammer\\Gxc.g:219:29: ( argument_expression_list )?
                    	int alt26 = 2;
                    	alt26 = dfa26.Predict(input);
                    	switch (alt26) 
                    	{
                    	    case 1 :
                    	        // GxcGrammer\\Gxc.g:0:0: argument_expression_list
                    	        {
                    	        	PushFollow(FOLLOW_argument_expression_list_in_postfix_expression1124);
                    	        	argument_expression_list139 = argument_expression_list();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( (state.backtracking==0) ) stream_argument_expression_list.Add(argument_expression_list139.Tree);

                    	        }
                    	        break;

                    	}

                    	char_literal140=(IToken)Match(input,50,FOLLOW_50_in_postfix_expression1127); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal140);



                    	// AST REWRITE
                    	// elements:          primary_expression, argument_expression_list
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 219:59: -> ^( FUNCTION_CALL ^( primary_expression ( argument_expression_list )? ) )
                    	{
                    	    // GxcGrammer\\Gxc.g:219:61: ^( FUNCTION_CALL ^( primary_expression ( argument_expression_list )? ) )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNCTION_CALL, "FUNCTION_CALL"), root_1);

                    	    // GxcGrammer\\Gxc.g:219:77: ^( primary_expression ( argument_expression_list )? )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot(stream_primary_expression.NextNode(), root_2);

                    	    // GxcGrammer\\Gxc.g:219:98: ( argument_expression_list )?
                    	    if ( stream_argument_expression_list.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_2, stream_argument_expression_list.NextTree());

                    	    }
                    	    stream_argument_expression_list.Reset();

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 23, postfix_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "postfix_expression"

    public class unary_operator_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "unary_operator"
    // GxcGrammer\\Gxc.g:222:1: unary_operator : ( '&' | '*' | '+' | '-' | '~' | '!' );
    public GxcParser.unary_operator_return unary_operator() // throws RecognitionException [1]
    {   
        GxcParser.unary_operator_return retval = new GxcParser.unary_operator_return();
        retval.Start = input.LT(1);
        int unary_operator_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal141 = null;
        IToken char_literal142 = null;
        IToken char_literal143 = null;
        IToken char_literal144 = null;
        IToken char_literal145 = null;
        IToken char_literal146 = null;

        CommonTree char_literal141_tree=null;
        CommonTree char_literal142_tree=null;
        CommonTree char_literal143_tree=null;
        CommonTree char_literal144_tree=null;
        CommonTree char_literal145_tree=null;
        CommonTree char_literal146_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 24) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:223:2: ( '&' | '*' | '+' | '-' | '~' | '!' )
            int alt28 = 6;
            switch ( input.LA(1) ) 
            {
            case 66:
            	{
                alt28 = 1;
                }
                break;
            case 60:
            	{
                alt28 = 2;
                }
                break;
            case 58:
            	{
                alt28 = 3;
                }
                break;
            case 59:
            	{
                alt28 = 4;
                }
                break;
            case 67:
            	{
                alt28 = 5;
                }
                break;
            case 68:
            	{
                alt28 = 6;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d28s0 =
            	        new NoViableAltException("", 28, 0, input);

            	    throw nvae_d28s0;
            }

            switch (alt28) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:223:4: '&'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal141=(IToken)Match(input,66,FOLLOW_66_in_unary_operator1150); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal141_tree = (CommonTree)adaptor.Create(char_literal141);
                    		adaptor.AddChild(root_0, char_literal141_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("&");
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:224:4: '*'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal142=(IToken)Match(input,60,FOLLOW_60_in_unary_operator1156); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal142_tree = (CommonTree)adaptor.Create(char_literal142);
                    		adaptor.AddChild(root_0, char_literal142_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("*");
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:225:4: '+'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal143=(IToken)Match(input,58,FOLLOW_58_in_unary_operator1162); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal143_tree = (CommonTree)adaptor.Create(char_literal143);
                    		adaptor.AddChild(root_0, char_literal143_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("+");
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:226:4: '-'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal144=(IToken)Match(input,59,FOLLOW_59_in_unary_operator1168); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal144_tree = (CommonTree)adaptor.Create(char_literal144);
                    		adaptor.AddChild(root_0, char_literal144_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("-");
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:227:4: '~'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal145=(IToken)Match(input,67,FOLLOW_67_in_unary_operator1174); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal145_tree = (CommonTree)adaptor.Create(char_literal145);
                    		adaptor.AddChild(root_0, char_literal145_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("~");
                    	}

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:228:4: '!'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal146=(IToken)Match(input,68,FOLLOW_68_in_unary_operator1180); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal146_tree = (CommonTree)adaptor.Create(char_literal146);
                    		adaptor.AddChild(root_0, char_literal146_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("!");
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 24, unary_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unary_operator"

    public class primary_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "primary_expression"
    // GxcGrammer\\Gxc.g:231:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );
    public GxcParser.primary_expression_return primary_expression() // throws RecognitionException [1]
    {   
        GxcParser.primary_expression_return retval = new GxcParser.primary_expression_return();
        retval.Start = input.LT(1);
        int primary_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IDENTIFIER147 = null;
        IToken char_literal149 = null;
        IToken char_literal151 = null;
        GxcParser.constant_return constant148 = default(GxcParser.constant_return);

        GxcParser.expression_return expression150 = default(GxcParser.expression_return);


        CommonTree IDENTIFIER147_tree=null;
        CommonTree char_literal149_tree=null;
        CommonTree char_literal151_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 25) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:232:2: ( IDENTIFIER | constant | '(' expression ')' )
            int alt29 = 3;
            alt29 = dfa29.Predict(input);
            switch (alt29) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:232:4: IDENTIFIER
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	IDENTIFIER147=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary_expression1192); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{IDENTIFIER147_tree = (CommonTree)adaptor.Create(IDENTIFIER147);
                    		adaptor.AddChild(root_0, IDENTIFIER147_tree);
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:233:4: constant
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_constant_in_primary_expression1197);
                    	constant148 = constant();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant148.Tree);

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:234:4: '(' expression ')'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal149=(IToken)Match(input,49,FOLLOW_49_in_primary_expression1202); if (state.failed) return retval;
                    	PushFollow(FOLLOW_expression_in_primary_expression1205);
                    	expression150 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression150.Tree);
                    	char_literal151=(IToken)Match(input,50,FOLLOW_50_in_primary_expression1207); if (state.failed) return retval;

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 25, primary_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_expression"

    public class constant_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "constant"
    // GxcGrammer\\Gxc.g:237:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | '(' 'int' ')' DECIMAL_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | FLOATING_POINT_LITERAL );
    public GxcParser.constant_return constant() // throws RecognitionException [1]
    {   
        GxcParser.constant_return retval = new GxcParser.constant_return();
        retval.Start = input.LT(1);
        int constant_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken HEX_LITERAL152 = null;
        IToken OCTAL_LITERAL153 = null;
        IToken DECIMAL_LITERAL154 = null;
        IToken char_literal155 = null;
        IToken string_literal156 = null;
        IToken char_literal157 = null;
        IToken DECIMAL_LITERAL158 = null;
        IToken CHARACTER_LITERAL159 = null;
        IToken STRING_LITERAL160 = null;
        IToken FLOATING_POINT_LITERAL161 = null;

        CommonTree HEX_LITERAL152_tree=null;
        CommonTree OCTAL_LITERAL153_tree=null;
        CommonTree DECIMAL_LITERAL154_tree=null;
        CommonTree char_literal155_tree=null;
        CommonTree string_literal156_tree=null;
        CommonTree char_literal157_tree=null;
        CommonTree DECIMAL_LITERAL158_tree=null;
        CommonTree CHARACTER_LITERAL159_tree=null;
        CommonTree STRING_LITERAL160_tree=null;
        CommonTree FLOATING_POINT_LITERAL161_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 26) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:238:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | '(' 'int' ')' DECIMAL_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | FLOATING_POINT_LITERAL )
            int alt30 = 7;
            switch ( input.LA(1) ) 
            {
            case HEX_LITERAL:
            	{
                alt30 = 1;
                }
                break;
            case OCTAL_LITERAL:
            	{
                alt30 = 2;
                }
                break;
            case DECIMAL_LITERAL:
            	{
                alt30 = 3;
                }
                break;
            case 49:
            	{
                alt30 = 4;
                }
                break;
            case CHARACTER_LITERAL:
            	{
                alt30 = 5;
                }
                break;
            case STRING_LITERAL:
            	{
                alt30 = 6;
                }
                break;
            case FLOATING_POINT_LITERAL:
            	{
                alt30 = 7;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d30s0 =
            	        new NoViableAltException("", 30, 0, input);

            	    throw nvae_d30s0;
            }

            switch (alt30) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:238:9: HEX_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	HEX_LITERAL152=(IToken)Match(input,HEX_LITERAL,FOLLOW_HEX_LITERAL_in_constant1224); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{HEX_LITERAL152_tree = (CommonTree)adaptor.Create(HEX_LITERAL152);
                    		adaptor.AddChild(root_0, HEX_LITERAL152_tree);
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:239:9: OCTAL_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OCTAL_LITERAL153=(IToken)Match(input,OCTAL_LITERAL,FOLLOW_OCTAL_LITERAL_in_constant1234); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OCTAL_LITERAL153_tree = (CommonTree)adaptor.Create(OCTAL_LITERAL153);
                    		adaptor.AddChild(root_0, OCTAL_LITERAL153_tree);
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:240:9: DECIMAL_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	DECIMAL_LITERAL154=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_constant1244); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{DECIMAL_LITERAL154_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL154);
                    		adaptor.AddChild(root_0, DECIMAL_LITERAL154_tree);
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:241:7: '(' 'int' ')' DECIMAL_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal155=(IToken)Match(input,49,FOLLOW_49_in_constant1252); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal155_tree = (CommonTree)adaptor.Create(char_literal155);
                    		adaptor.AddChild(root_0, char_literal155_tree);
                    	}
                    	string_literal156=(IToken)Match(input,52,FOLLOW_52_in_constant1254); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal156_tree = (CommonTree)adaptor.Create(string_literal156);
                    		adaptor.AddChild(root_0, string_literal156_tree);
                    	}
                    	char_literal157=(IToken)Match(input,50,FOLLOW_50_in_constant1256); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal157_tree = (CommonTree)adaptor.Create(char_literal157);
                    		adaptor.AddChild(root_0, char_literal157_tree);
                    	}
                    	DECIMAL_LITERAL158=(IToken)Match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_constant1259); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{DECIMAL_LITERAL158_tree = (CommonTree)adaptor.Create(DECIMAL_LITERAL158);
                    		adaptor.AddChild(root_0, DECIMAL_LITERAL158_tree);
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:242:7: CHARACTER_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	CHARACTER_LITERAL159=(IToken)Match(input,CHARACTER_LITERAL,FOLLOW_CHARACTER_LITERAL_in_constant1268); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{CHARACTER_LITERAL159_tree = (CommonTree)adaptor.Create(CHARACTER_LITERAL159);
                    		adaptor.AddChild(root_0, CHARACTER_LITERAL159_tree);
                    	}

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:243:7: STRING_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	STRING_LITERAL160=(IToken)Match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_constant1276); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{STRING_LITERAL160_tree = (CommonTree)adaptor.Create(STRING_LITERAL160);
                    		adaptor.AddChild(root_0, STRING_LITERAL160_tree);
                    	}

                    }
                    break;
                case 7 :
                    // GxcGrammer\\Gxc.g:244:9: FLOATING_POINT_LITERAL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	FLOATING_POINT_LITERAL161=(IToken)Match(input,FLOATING_POINT_LITERAL,FOLLOW_FLOATING_POINT_LITERAL_in_constant1286); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{FLOATING_POINT_LITERAL161_tree = (CommonTree)adaptor.Create(FLOATING_POINT_LITERAL161);
                    		adaptor.AddChild(root_0, FLOATING_POINT_LITERAL161_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 26, constant_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant"

    public class expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expression"
    // GxcGrammer\\Gxc.g:249:1: expression : assignment_expression ( ',' assignment_expression )* ;
    public GxcParser.expression_return expression() // throws RecognitionException [1]
    {   
        GxcParser.expression_return retval = new GxcParser.expression_return();
        retval.Start = input.LT(1);
        int expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal163 = null;
        GxcParser.assignment_expression_return assignment_expression162 = default(GxcParser.assignment_expression_return);

        GxcParser.assignment_expression_return assignment_expression164 = default(GxcParser.assignment_expression_return);


        CommonTree char_literal163_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 27) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:250:2: ( assignment_expression ( ',' assignment_expression )* )
            // GxcGrammer\\Gxc.g:250:4: assignment_expression ( ',' assignment_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_assignment_expression_in_expression1302);
            	assignment_expression162 = assignment_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_expression162.Tree);
            	// GxcGrammer\\Gxc.g:250:26: ( ',' assignment_expression )*
            	do 
            	{
            	    int alt31 = 2;
            	    int LA31_0 = input.LA(1);

            	    if ( (LA31_0 == 47) )
            	    {
            	        alt31 = 1;
            	    }


            	    switch (alt31) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:250:27: ',' assignment_expression
            			    {
            			    	char_literal163=(IToken)Match(input,47,FOLLOW_47_in_expression1305); if (state.failed) return retval;
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount(",");
            			    	}
            			    	PushFollow(FOLLOW_assignment_expression_in_expression1309);
            			    	assignment_expression164 = assignment_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_expression164.Tree);

            			    }
            			    break;

            			default:
            			    goto loop31;
            	    }
            	} while (true);

            	loop31:
            		;	// Stops C# compiler whining that label 'loop31' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 27, expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression"

    public class constant_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "constant_expression"
    // GxcGrammer\\Gxc.g:253:1: constant_expression : conditional_expression ;
    public GxcParser.constant_expression_return constant_expression() // throws RecognitionException [1]
    {   
        GxcParser.constant_expression_return retval = new GxcParser.constant_expression_return();
        retval.Start = input.LT(1);
        int constant_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.conditional_expression_return conditional_expression165 = default(GxcParser.conditional_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 28) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:254:2: ( conditional_expression )
            // GxcGrammer\\Gxc.g:254:4: conditional_expression
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_conditional_expression_in_constant_expression1322);
            	conditional_expression165 = conditional_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_expression165.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 28, constant_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_expression"

    public class assignment_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "assignment_expression"
    // GxcGrammer\\Gxc.g:257:1: assignment_expression : ( lvalue assignment_operator assignment_expression -> ^( ASSIGNMENT lvalue assignment_expression ) | conditional_expression );
    public GxcParser.assignment_expression_return assignment_expression() // throws RecognitionException [1]
    {   
        GxcParser.assignment_expression_return retval = new GxcParser.assignment_expression_return();
        retval.Start = input.LT(1);
        int assignment_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.lvalue_return lvalue166 = default(GxcParser.lvalue_return);

        GxcParser.assignment_operator_return assignment_operator167 = default(GxcParser.assignment_operator_return);

        GxcParser.assignment_expression_return assignment_expression168 = default(GxcParser.assignment_expression_return);

        GxcParser.conditional_expression_return conditional_expression169 = default(GxcParser.conditional_expression_return);


        RewriteRuleSubtreeStream stream_lvalue = new RewriteRuleSubtreeStream(adaptor,"rule lvalue");
        RewriteRuleSubtreeStream stream_assignment_operator = new RewriteRuleSubtreeStream(adaptor,"rule assignment_operator");
        RewriteRuleSubtreeStream stream_assignment_expression = new RewriteRuleSubtreeStream(adaptor,"rule assignment_expression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 29) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:258:2: ( lvalue assignment_operator assignment_expression -> ^( ASSIGNMENT lvalue assignment_expression ) | conditional_expression )
            int alt32 = 2;
            alt32 = dfa32.Predict(input);
            switch (alt32) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:258:4: lvalue assignment_operator assignment_expression
                    {
                    	PushFollow(FOLLOW_lvalue_in_assignment_expression1333);
                    	lvalue166 = lvalue();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_lvalue.Add(lvalue166.Tree);
                    	PushFollow(FOLLOW_assignment_operator_in_assignment_expression1335);
                    	assignment_operator167 = assignment_operator();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_assignment_operator.Add(assignment_operator167.Tree);
                    	PushFollow(FOLLOW_assignment_expression_in_assignment_expression1337);
                    	assignment_expression168 = assignment_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_assignment_expression.Add(assignment_expression168.Tree);


                    	// AST REWRITE
                    	// elements:          lvalue, assignment_expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 258:53: -> ^( ASSIGNMENT lvalue assignment_expression )
                    	{
                    	    // GxcGrammer\\Gxc.g:258:56: ^( ASSIGNMENT lvalue assignment_expression )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ASSIGNMENT, "ASSIGNMENT"), root_1);

                    	    adaptor.AddChild(root_1, stream_lvalue.NextTree());
                    	    adaptor.AddChild(root_1, stream_assignment_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:259:4: conditional_expression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_conditional_expression_in_assignment_expression1352);
                    	conditional_expression169 = conditional_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_expression169.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 29, assignment_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignment_expression"

    public class lvalue_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "lvalue"
    // GxcGrammer\\Gxc.g:262:1: lvalue : unary_expression ;
    public GxcParser.lvalue_return lvalue() // throws RecognitionException [1]
    {   
        GxcParser.lvalue_return retval = new GxcParser.lvalue_return();
        retval.Start = input.LT(1);
        int lvalue_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.unary_expression_return unary_expression170 = default(GxcParser.unary_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 30) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:263:2: ( unary_expression )
            // GxcGrammer\\Gxc.g:263:4: unary_expression
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_unary_expression_in_lvalue1364);
            	unary_expression170 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression170.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 30, lvalue_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "lvalue"

    public class assignment_operator_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "assignment_operator"
    // GxcGrammer\\Gxc.g:266:1: assignment_operator : ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' );
    public GxcParser.assignment_operator_return assignment_operator() // throws RecognitionException [1]
    {   
        GxcParser.assignment_operator_return retval = new GxcParser.assignment_operator_return();
        retval.Start = input.LT(1);
        int assignment_operator_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal171 = null;
        IToken string_literal172 = null;
        IToken string_literal173 = null;
        IToken string_literal174 = null;
        IToken string_literal175 = null;
        IToken string_literal176 = null;
        IToken string_literal177 = null;
        IToken string_literal178 = null;
        IToken string_literal179 = null;
        IToken string_literal180 = null;
        IToken string_literal181 = null;

        CommonTree char_literal171_tree=null;
        CommonTree string_literal172_tree=null;
        CommonTree string_literal173_tree=null;
        CommonTree string_literal174_tree=null;
        CommonTree string_literal175_tree=null;
        CommonTree string_literal176_tree=null;
        CommonTree string_literal177_tree=null;
        CommonTree string_literal178_tree=null;
        CommonTree string_literal179_tree=null;
        CommonTree string_literal180_tree=null;
        CommonTree string_literal181_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 31) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:267:2: ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' )
            int alt33 = 11;
            alt33 = dfa33.Predict(input);
            switch (alt33) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:267:4: '='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal171=(IToken)Match(input,42,FOLLOW_42_in_assignment_operator1375); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal171_tree = (CommonTree)adaptor.Create(char_literal171);
                    		adaptor.AddChild(root_0, char_literal171_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("=");
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:268:4: '*='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal172=(IToken)Match(input,69,FOLLOW_69_in_assignment_operator1381); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal172_tree = (CommonTree)adaptor.Create(string_literal172);
                    		adaptor.AddChild(root_0, string_literal172_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("*=");
                    	}

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:269:4: '/='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal173=(IToken)Match(input,70,FOLLOW_70_in_assignment_operator1387); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal173_tree = (CommonTree)adaptor.Create(string_literal173);
                    		adaptor.AddChild(root_0, string_literal173_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("/=");
                    	}

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:270:4: '%='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal174=(IToken)Match(input,71,FOLLOW_71_in_assignment_operator1393); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal174_tree = (CommonTree)adaptor.Create(string_literal174);
                    		adaptor.AddChild(root_0, string_literal174_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("mod=");
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:271:4: '+='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal175=(IToken)Match(input,72,FOLLOW_72_in_assignment_operator1399); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal175_tree = (CommonTree)adaptor.Create(string_literal175);
                    		adaptor.AddChild(root_0, string_literal175_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("+=");
                    	}

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:272:4: '-='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal176=(IToken)Match(input,73,FOLLOW_73_in_assignment_operator1405); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal176_tree = (CommonTree)adaptor.Create(string_literal176);
                    		adaptor.AddChild(root_0, string_literal176_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("-=");
                    	}

                    }
                    break;
                case 7 :
                    // GxcGrammer\\Gxc.g:273:4: '<<='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal177=(IToken)Match(input,74,FOLLOW_74_in_assignment_operator1411); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal177_tree = (CommonTree)adaptor.Create(string_literal177);
                    		adaptor.AddChild(root_0, string_literal177_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("<<=");
                    	}

                    }
                    break;
                case 8 :
                    // GxcGrammer\\Gxc.g:274:4: '>>='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal178=(IToken)Match(input,75,FOLLOW_75_in_assignment_operator1417); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal178_tree = (CommonTree)adaptor.Create(string_literal178);
                    		adaptor.AddChild(root_0, string_literal178_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount(">>=");
                    	}

                    }
                    break;
                case 9 :
                    // GxcGrammer\\Gxc.g:275:4: '&='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal179=(IToken)Match(input,76,FOLLOW_76_in_assignment_operator1423); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal179_tree = (CommonTree)adaptor.Create(string_literal179);
                    		adaptor.AddChild(root_0, string_literal179_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("&=");
                    	}

                    }
                    break;
                case 10 :
                    // GxcGrammer\\Gxc.g:276:4: '^='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal180=(IToken)Match(input,77,FOLLOW_77_in_assignment_operator1429); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal180_tree = (CommonTree)adaptor.Create(string_literal180);
                    		adaptor.AddChild(root_0, string_literal180_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("^=");
                    	}

                    }
                    break;
                case 11 :
                    // GxcGrammer\\Gxc.g:277:4: '|='
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal181=(IToken)Match(input,78,FOLLOW_78_in_assignment_operator1435); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal181_tree = (CommonTree)adaptor.Create(string_literal181);
                    		adaptor.AddChild(root_0, string_literal181_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("|=");
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 31, assignment_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignment_operator"

    public class conditional_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "conditional_expression"
    // GxcGrammer\\Gxc.g:280:1: conditional_expression : logical_or_expression ( '?' expression ':' conditional_expression )? ;
    public GxcParser.conditional_expression_return conditional_expression() // throws RecognitionException [1]
    {   
        GxcParser.conditional_expression_return retval = new GxcParser.conditional_expression_return();
        retval.Start = input.LT(1);
        int conditional_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal183 = null;
        IToken char_literal185 = null;
        GxcParser.logical_or_expression_return logical_or_expression182 = default(GxcParser.logical_or_expression_return);

        GxcParser.expression_return expression184 = default(GxcParser.expression_return);

        GxcParser.conditional_expression_return conditional_expression186 = default(GxcParser.conditional_expression_return);


        CommonTree char_literal183_tree=null;
        CommonTree char_literal185_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 32) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:281:2: ( logical_or_expression ( '?' expression ':' conditional_expression )? )
            // GxcGrammer\\Gxc.g:281:4: logical_or_expression ( '?' expression ':' conditional_expression )?
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_logical_or_expression_in_conditional_expression1447);
            	logical_or_expression182 = logical_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, logical_or_expression182.Tree);
            	// GxcGrammer\\Gxc.g:281:26: ( '?' expression ':' conditional_expression )?
            	int alt34 = 2;
            	int LA34_0 = input.LA(1);

            	if ( (LA34_0 == 79) )
            	{
            	    alt34 = 1;
            	}
            	switch (alt34) 
            	{
            	    case 1 :
            	        // GxcGrammer\\Gxc.g:281:27: '?' expression ':' conditional_expression
            	        {
            	        	char_literal183=(IToken)Match(input,79,FOLLOW_79_in_conditional_expression1450); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal183_tree = (CommonTree)adaptor.Create(char_literal183);
            	        		adaptor.AddChild(root_0, char_literal183_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_conditional_expression1452);
            	        	expression184 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression184.Tree);
            	        	char_literal185=(IToken)Match(input,80,FOLLOW_80_in_conditional_expression1454); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal185_tree = (CommonTree)adaptor.Create(char_literal185);
            	        		adaptor.AddChild(root_0, char_literal185_tree);
            	        	}
            	        	PushFollow(FOLLOW_conditional_expression_in_conditional_expression1456);
            	        	conditional_expression186 = conditional_expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_expression186.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 32, conditional_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conditional_expression"

    public class logical_or_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "logical_or_expression"
    // GxcGrammer\\Gxc.g:284:1: logical_or_expression : logical_and_expression ( '||' logical_and_expression )* ;
    public GxcParser.logical_or_expression_return logical_or_expression() // throws RecognitionException [1]
    {   
        GxcParser.logical_or_expression_return retval = new GxcParser.logical_or_expression_return();
        retval.Start = input.LT(1);
        int logical_or_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal188 = null;
        GxcParser.logical_and_expression_return logical_and_expression187 = default(GxcParser.logical_and_expression_return);

        GxcParser.logical_and_expression_return logical_and_expression189 = default(GxcParser.logical_and_expression_return);


        CommonTree string_literal188_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 33) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:285:2: ( logical_and_expression ( '||' logical_and_expression )* )
            // GxcGrammer\\Gxc.g:285:4: logical_and_expression ( '||' logical_and_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_logical_and_expression_in_logical_or_expression1469);
            	logical_and_expression187 = logical_and_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, logical_and_expression187.Tree);
            	// GxcGrammer\\Gxc.g:285:27: ( '||' logical_and_expression )*
            	do 
            	{
            	    int alt35 = 2;
            	    int LA35_0 = input.LA(1);

            	    if ( (LA35_0 == 81) )
            	    {
            	        alt35 = 1;
            	    }


            	    switch (alt35) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:285:28: '||' logical_and_expression
            			    {
            			    	string_literal188=(IToken)Match(input,81,FOLLOW_81_in_logical_or_expression1472); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal188_tree = (CommonTree)adaptor.Create(string_literal188);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal188_tree, root_0);
            			    	}
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount("||");
            			    	}
            			    	PushFollow(FOLLOW_logical_and_expression_in_logical_or_expression1476);
            			    	logical_and_expression189 = logical_and_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, logical_and_expression189.Tree);

            			    }
            			    break;

            			default:
            			    goto loop35;
            	    }
            	} while (true);

            	loop35:
            		;	// Stops C# compiler whining that label 'loop35' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 33, logical_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "logical_or_expression"

    public class logical_and_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "logical_and_expression"
    // GxcGrammer\\Gxc.g:288:1: logical_and_expression : inclusive_or_expression ( '&&' inclusive_or_expression )* ;
    public GxcParser.logical_and_expression_return logical_and_expression() // throws RecognitionException [1]
    {   
        GxcParser.logical_and_expression_return retval = new GxcParser.logical_and_expression_return();
        retval.Start = input.LT(1);
        int logical_and_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal191 = null;
        GxcParser.inclusive_or_expression_return inclusive_or_expression190 = default(GxcParser.inclusive_or_expression_return);

        GxcParser.inclusive_or_expression_return inclusive_or_expression192 = default(GxcParser.inclusive_or_expression_return);


        CommonTree string_literal191_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 34) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:289:2: ( inclusive_or_expression ( '&&' inclusive_or_expression )* )
            // GxcGrammer\\Gxc.g:289:4: inclusive_or_expression ( '&&' inclusive_or_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_inclusive_or_expression_in_logical_and_expression1489);
            	inclusive_or_expression190 = inclusive_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression190.Tree);
            	// GxcGrammer\\Gxc.g:289:28: ( '&&' inclusive_or_expression )*
            	do 
            	{
            	    int alt36 = 2;
            	    alt36 = dfa36.Predict(input);
            	    switch (alt36) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:289:29: '&&' inclusive_or_expression
            			    {
            			    	string_literal191=(IToken)Match(input,82,FOLLOW_82_in_logical_and_expression1492); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal191_tree = (CommonTree)adaptor.Create(string_literal191);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal191_tree, root_0);
            			    	}
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount("&&");
            			    	}
            			    	PushFollow(FOLLOW_inclusive_or_expression_in_logical_and_expression1496);
            			    	inclusive_or_expression192 = inclusive_or_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression192.Tree);

            			    }
            			    break;

            			default:
            			    goto loop36;
            	    }
            	} while (true);

            	loop36:
            		;	// Stops C# compiler whining that label 'loop36' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 34, logical_and_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "logical_and_expression"

    public class inclusive_or_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "inclusive_or_expression"
    // GxcGrammer\\Gxc.g:292:1: inclusive_or_expression : exclusive_or_expression ( '|' exclusive_or_expression )* ;
    public GxcParser.inclusive_or_expression_return inclusive_or_expression() // throws RecognitionException [1]
    {   
        GxcParser.inclusive_or_expression_return retval = new GxcParser.inclusive_or_expression_return();
        retval.Start = input.LT(1);
        int inclusive_or_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal194 = null;
        GxcParser.exclusive_or_expression_return exclusive_or_expression193 = default(GxcParser.exclusive_or_expression_return);

        GxcParser.exclusive_or_expression_return exclusive_or_expression195 = default(GxcParser.exclusive_or_expression_return);


        CommonTree char_literal194_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 35) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:293:2: ( exclusive_or_expression ( '|' exclusive_or_expression )* )
            // GxcGrammer\\Gxc.g:293:4: exclusive_or_expression ( '|' exclusive_or_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression1509);
            	exclusive_or_expression193 = exclusive_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression193.Tree);
            	// GxcGrammer\\Gxc.g:293:28: ( '|' exclusive_or_expression )*
            	do 
            	{
            	    int alt37 = 2;
            	    alt37 = dfa37.Predict(input);
            	    switch (alt37) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:293:29: '|' exclusive_or_expression
            			    {
            			    	char_literal194=(IToken)Match(input,83,FOLLOW_83_in_inclusive_or_expression1512); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal194_tree = (CommonTree)adaptor.Create(char_literal194);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal194_tree, root_0);
            			    	}
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount("|");
            			    	}
            			    	PushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression1516);
            			    	exclusive_or_expression195 = exclusive_or_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression195.Tree);

            			    }
            			    break;

            			default:
            			    goto loop37;
            	    }
            	} while (true);

            	loop37:
            		;	// Stops C# compiler whining that label 'loop37' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 35, inclusive_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "inclusive_or_expression"

    public class exclusive_or_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "exclusive_or_expression"
    // GxcGrammer\\Gxc.g:296:1: exclusive_or_expression : and_expression ( '^' and_expression )* ;
    public GxcParser.exclusive_or_expression_return exclusive_or_expression() // throws RecognitionException [1]
    {   
        GxcParser.exclusive_or_expression_return retval = new GxcParser.exclusive_or_expression_return();
        retval.Start = input.LT(1);
        int exclusive_or_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal197 = null;
        GxcParser.and_expression_return and_expression196 = default(GxcParser.and_expression_return);

        GxcParser.and_expression_return and_expression198 = default(GxcParser.and_expression_return);


        CommonTree char_literal197_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 36) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:297:2: ( and_expression ( '^' and_expression )* )
            // GxcGrammer\\Gxc.g:297:4: and_expression ( '^' and_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_and_expression_in_exclusive_or_expression1529);
            	and_expression196 = and_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression196.Tree);
            	// GxcGrammer\\Gxc.g:297:19: ( '^' and_expression )*
            	do 
            	{
            	    int alt38 = 2;
            	    alt38 = dfa38.Predict(input);
            	    switch (alt38) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:297:20: '^' and_expression
            			    {
            			    	char_literal197=(IToken)Match(input,84,FOLLOW_84_in_exclusive_or_expression1532); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal197_tree = (CommonTree)adaptor.Create(char_literal197);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal197_tree, root_0);
            			    	}
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount("^");
            			    	}
            			    	PushFollow(FOLLOW_and_expression_in_exclusive_or_expression1536);
            			    	and_expression198 = and_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression198.Tree);

            			    }
            			    break;

            			default:
            			    goto loop38;
            	    }
            	} while (true);

            	loop38:
            		;	// Stops C# compiler whining that label 'loop38' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 36, exclusive_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "exclusive_or_expression"

    public class and_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "and_expression"
    // GxcGrammer\\Gxc.g:300:1: and_expression : equality_expression ( '&' equality_expression )* ;
    public GxcParser.and_expression_return and_expression() // throws RecognitionException [1]
    {   
        GxcParser.and_expression_return retval = new GxcParser.and_expression_return();
        retval.Start = input.LT(1);
        int and_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal200 = null;
        GxcParser.equality_expression_return equality_expression199 = default(GxcParser.equality_expression_return);

        GxcParser.equality_expression_return equality_expression201 = default(GxcParser.equality_expression_return);


        CommonTree char_literal200_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 37) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:301:2: ( equality_expression ( '&' equality_expression )* )
            // GxcGrammer\\Gxc.g:301:4: equality_expression ( '&' equality_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_equality_expression_in_and_expression1549);
            	equality_expression199 = equality_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression199.Tree);
            	// GxcGrammer\\Gxc.g:301:24: ( '&' equality_expression )*
            	do 
            	{
            	    int alt39 = 2;
            	    alt39 = dfa39.Predict(input);
            	    switch (alt39) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:301:25: '&' equality_expression
            			    {
            			    	char_literal200=(IToken)Match(input,66,FOLLOW_66_in_and_expression1552); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal200_tree = (CommonTree)adaptor.Create(char_literal200);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(char_literal200_tree, root_0);
            			    	}
            			    	if ( (state.backtracking==0) )
            			    	{
            			    	  IncrementOperatorCount("&");
            			    	}
            			    	PushFollow(FOLLOW_equality_expression_in_and_expression1556);
            			    	equality_expression201 = equality_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression201.Tree);

            			    }
            			    break;

            			default:
            			    goto loop39;
            	    }
            	} while (true);

            	loop39:
            		;	// Stops C# compiler whining that label 'loop39' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 37, and_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "and_expression"

    public class equality_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "equality_expression"
    // GxcGrammer\\Gxc.g:303:1: equality_expression : relational_expression ( ( '==' | '!=' ) relational_expression )* ;
    public GxcParser.equality_expression_return equality_expression() // throws RecognitionException [1]
    {   
        GxcParser.equality_expression_return retval = new GxcParser.equality_expression_return();
        retval.Start = input.LT(1);
        int equality_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal203 = null;
        IToken string_literal204 = null;
        GxcParser.relational_expression_return relational_expression202 = default(GxcParser.relational_expression_return);

        GxcParser.relational_expression_return relational_expression205 = default(GxcParser.relational_expression_return);


        CommonTree string_literal203_tree=null;
        CommonTree string_literal204_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 38) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:304:2: ( relational_expression ( ( '==' | '!=' ) relational_expression )* )
            // GxcGrammer\\Gxc.g:304:4: relational_expression ( ( '==' | '!=' ) relational_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_relational_expression_in_equality_expression1568);
            	relational_expression202 = relational_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression202.Tree);
            	// GxcGrammer\\Gxc.g:304:26: ( ( '==' | '!=' ) relational_expression )*
            	do 
            	{
            	    int alt41 = 2;
            	    alt41 = dfa41.Predict(input);
            	    switch (alt41) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:304:27: ( '==' | '!=' ) relational_expression
            			    {
            			    	// GxcGrammer\\Gxc.g:304:27: ( '==' | '!=' )
            			    	int alt40 = 2;
            			    	int LA40_0 = input.LA(1);

            			    	if ( (LA40_0 == 85) )
            			    	{
            			    	    alt40 = 1;
            			    	}
            			    	else if ( (LA40_0 == 86) )
            			    	{
            			    	    alt40 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d40s0 =
            			    	        new NoViableAltException("", 40, 0, input);

            			    	    throw nvae_d40s0;
            			    	}
            			    	switch (alt40) 
            			    	{
            			    	    case 1 :
            			    	        // GxcGrammer\\Gxc.g:304:28: '=='
            			    	        {
            			    	        	string_literal203=(IToken)Match(input,85,FOLLOW_85_in_equality_expression1572); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal203_tree = (CommonTree)adaptor.Create(string_literal203);
            			    	        		adaptor.AddChild(root_0, string_literal203_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount("==");
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // GxcGrammer\\Gxc.g:304:64: '!='
            			    	        {
            			    	        	string_literal204=(IToken)Match(input,86,FOLLOW_86_in_equality_expression1575); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal204_tree = (CommonTree)adaptor.Create(string_literal204);
            			    	        		adaptor.AddChild(root_0, string_literal204_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount("!=");
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_relational_expression_in_equality_expression1580);
            			    	relational_expression205 = relational_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression205.Tree);

            			    }
            			    break;

            			default:
            			    goto loop41;
            	    }
            	} while (true);

            	loop41:
            		;	// Stops C# compiler whining that label 'loop41' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 38, equality_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "equality_expression"

    public class relational_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "relational_expression"
    // GxcGrammer\\Gxc.g:307:1: relational_expression : shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* ;
    public GxcParser.relational_expression_return relational_expression() // throws RecognitionException [1]
    {   
        GxcParser.relational_expression_return retval = new GxcParser.relational_expression_return();
        retval.Start = input.LT(1);
        int relational_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal207 = null;
        IToken char_literal208 = null;
        IToken string_literal209 = null;
        IToken string_literal210 = null;
        GxcParser.shift_expression_return shift_expression206 = default(GxcParser.shift_expression_return);

        GxcParser.shift_expression_return shift_expression211 = default(GxcParser.shift_expression_return);


        CommonTree char_literal207_tree=null;
        CommonTree char_literal208_tree=null;
        CommonTree string_literal209_tree=null;
        CommonTree string_literal210_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 39) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:308:2: ( shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* )
            // GxcGrammer\\Gxc.g:308:4: shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_shift_expression_in_relational_expression1593);
            	shift_expression206 = shift_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression206.Tree);
            	// GxcGrammer\\Gxc.g:308:21: ( ( '<' | '>' | '<=' | '>=' ) shift_expression )*
            	do 
            	{
            	    int alt43 = 2;
            	    alt43 = dfa43.Predict(input);
            	    switch (alt43) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:308:22: ( '<' | '>' | '<=' | '>=' ) shift_expression
            			    {
            			    	// GxcGrammer\\Gxc.g:308:22: ( '<' | '>' | '<=' | '>=' )
            			    	int alt42 = 4;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case 87:
            			    		{
            			    	    alt42 = 1;
            			    	    }
            			    	    break;
            			    	case 88:
            			    		{
            			    	    alt42 = 2;
            			    	    }
            			    	    break;
            			    	case 89:
            			    		{
            			    	    alt42 = 3;
            			    	    }
            			    	    break;
            			    	case 90:
            			    		{
            			    	    alt42 = 4;
            			    	    }
            			    	    break;
            			    		default:
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    NoViableAltException nvae_d42s0 =
            			    		        new NoViableAltException("", 42, 0, input);

            			    		    throw nvae_d42s0;
            			    	}

            			    	switch (alt42) 
            			    	{
            			    	    case 1 :
            			    	        // GxcGrammer\\Gxc.g:308:23: '<'
            			    	        {
            			    	        	char_literal207=(IToken)Match(input,87,FOLLOW_87_in_relational_expression1597); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{char_literal207_tree = (CommonTree)adaptor.Create(char_literal207);
            			    	        		adaptor.AddChild(root_0, char_literal207_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount("<");
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // GxcGrammer\\Gxc.g:308:57: '>'
            			    	        {
            			    	        	char_literal208=(IToken)Match(input,88,FOLLOW_88_in_relational_expression1600); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{char_literal208_tree = (CommonTree)adaptor.Create(char_literal208);
            			    	        		adaptor.AddChild(root_0, char_literal208_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount(">");
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // GxcGrammer\\Gxc.g:308:91: '<='
            			    	        {
            			    	        	string_literal209=(IToken)Match(input,89,FOLLOW_89_in_relational_expression1603); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal209_tree = (CommonTree)adaptor.Create(string_literal209);
            			    	        		adaptor.AddChild(root_0, string_literal209_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount("<=");
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 4 :
            			    	        // GxcGrammer\\Gxc.g:308:127: '>='
            			    	        {
            			    	        	string_literal210=(IToken)Match(input,90,FOLLOW_90_in_relational_expression1606); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal210_tree = (CommonTree)adaptor.Create(string_literal210);
            			    	        		adaptor.AddChild(root_0, string_literal210_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount(">=");
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_shift_expression_in_relational_expression1611);
            			    	shift_expression211 = shift_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression211.Tree);

            			    }
            			    break;

            			default:
            			    goto loop43;
            	    }
            	} while (true);

            	loop43:
            		;	// Stops C# compiler whining that label 'loop43' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 39, relational_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "relational_expression"

    public class shift_expression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "shift_expression"
    // GxcGrammer\\Gxc.g:311:1: shift_expression : additive_expression ( ( '<<' | '>>' ) additive_expression )* ;
    public GxcParser.shift_expression_return shift_expression() // throws RecognitionException [1]
    {   
        GxcParser.shift_expression_return retval = new GxcParser.shift_expression_return();
        retval.Start = input.LT(1);
        int shift_expression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal213 = null;
        IToken string_literal214 = null;
        GxcParser.additive_expression_return additive_expression212 = default(GxcParser.additive_expression_return);

        GxcParser.additive_expression_return additive_expression215 = default(GxcParser.additive_expression_return);


        CommonTree string_literal213_tree=null;
        CommonTree string_literal214_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 40) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:312:2: ( additive_expression ( ( '<<' | '>>' ) additive_expression )* )
            // GxcGrammer\\Gxc.g:312:4: additive_expression ( ( '<<' | '>>' ) additive_expression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_additive_expression_in_shift_expression1624);
            	additive_expression212 = additive_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression212.Tree);
            	// GxcGrammer\\Gxc.g:312:24: ( ( '<<' | '>>' ) additive_expression )*
            	do 
            	{
            	    int alt45 = 2;
            	    alt45 = dfa45.Predict(input);
            	    switch (alt45) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:312:25: ( '<<' | '>>' ) additive_expression
            			    {
            			    	// GxcGrammer\\Gxc.g:312:25: ( '<<' | '>>' )
            			    	int alt44 = 2;
            			    	int LA44_0 = input.LA(1);

            			    	if ( (LA44_0 == 91) )
            			    	{
            			    	    alt44 = 1;
            			    	}
            			    	else if ( (LA44_0 == 92) )
            			    	{
            			    	    alt44 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d44s0 =
            			    	        new NoViableAltException("", 44, 0, input);

            			    	    throw nvae_d44s0;
            			    	}
            			    	switch (alt44) 
            			    	{
            			    	    case 1 :
            			    	        // GxcGrammer\\Gxc.g:312:26: '<<'
            			    	        {
            			    	        	string_literal213=(IToken)Match(input,91,FOLLOW_91_in_shift_expression1628); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal213_tree = (CommonTree)adaptor.Create(string_literal213);
            			    	        		adaptor.AddChild(root_0, string_literal213_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount("<<");
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // GxcGrammer\\Gxc.g:312:62: '>>'
            			    	        {
            			    	        	string_literal214=(IToken)Match(input,92,FOLLOW_92_in_shift_expression1631); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal214_tree = (CommonTree)adaptor.Create(string_literal214);
            			    	        		adaptor.AddChild(root_0, string_literal214_tree);
            			    	        	}
            			    	        	if ( (state.backtracking==0) )
            			    	        	{
            			    	        	  IncrementOperatorCount(">>");
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_additive_expression_in_shift_expression1636);
            			    	additive_expression215 = additive_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression215.Tree);

            			    }
            			    break;

            			default:
            			    goto loop45;
            	    }
            	} while (true);

            	loop45:
            		;	// Stops C# compiler whining that label 'loop45' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 40, shift_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "shift_expression"

    public class statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "statement"
    // GxcGrammer\\Gxc.g:317:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | comment_statement );
    public GxcParser.statement_return statement() // throws RecognitionException [1]
    {   
        GxcParser.statement_return retval = new GxcParser.statement_return();
        retval.Start = input.LT(1);
        int statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.labeled_statement_return labeled_statement216 = default(GxcParser.labeled_statement_return);

        GxcParser.compound_statement_return compound_statement217 = default(GxcParser.compound_statement_return);

        GxcParser.expression_statement_return expression_statement218 = default(GxcParser.expression_statement_return);

        GxcParser.selection_statement_return selection_statement219 = default(GxcParser.selection_statement_return);

        GxcParser.iteration_statement_return iteration_statement220 = default(GxcParser.iteration_statement_return);

        GxcParser.jump_statement_return jump_statement221 = default(GxcParser.jump_statement_return);

        GxcParser.comment_statement_return comment_statement222 = default(GxcParser.comment_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 41) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:318:2: ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | comment_statement )
            int alt46 = 7;
            alt46 = dfa46.Predict(input);
            switch (alt46) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:318:4: labeled_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_labeled_statement_in_statement1651);
                    	labeled_statement216 = labeled_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, labeled_statement216.Tree);

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:319:4: compound_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_compound_statement_in_statement1657);
                    	compound_statement217 = compound_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, compound_statement217.Tree);

                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:320:4: expression_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_statement_in_statement1662);
                    	expression_statement218 = expression_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_statement218.Tree);

                    }
                    break;
                case 4 :
                    // GxcGrammer\\Gxc.g:321:4: selection_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_selection_statement_in_statement1667);
                    	selection_statement219 = selection_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, selection_statement219.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  CyclomaticComplexity++;
                    	}

                    }
                    break;
                case 5 :
                    // GxcGrammer\\Gxc.g:322:4: iteration_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_iteration_statement_in_statement1674);
                    	iteration_statement220 = iteration_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, iteration_statement220.Tree);
                    	if ( (state.backtracking==0) )
                    	{
                    	  CyclomaticComplexity++;
                    	}

                    }
                    break;
                case 6 :
                    // GxcGrammer\\Gxc.g:323:4: jump_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_jump_statement_in_statement1681);
                    	jump_statement221 = jump_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, jump_statement221.Tree);

                    }
                    break;
                case 7 :
                    // GxcGrammer\\Gxc.g:324:4: comment_statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_comment_statement_in_statement1686);
                    	comment_statement222 = comment_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, comment_statement222.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 41, statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public class labeled_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "labeled_statement"
    // GxcGrammer\\Gxc.g:328:1: labeled_statement : ( IDENTIFIER ':' statement | 'case' constant_expression ':' statement -> ^( CASE constant_expression ^( CODE_BLOCK ) ( statement )? ) | 'default' ':' statement -> ^( DEFAULT_CASE ^( CODE_BLOCK ) ( statement )? ) );
    public GxcParser.labeled_statement_return labeled_statement() // throws RecognitionException [1]
    {   
        GxcParser.labeled_statement_return retval = new GxcParser.labeled_statement_return();
        retval.Start = input.LT(1);
        int labeled_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IDENTIFIER223 = null;
        IToken char_literal224 = null;
        IToken string_literal226 = null;
        IToken char_literal228 = null;
        IToken string_literal230 = null;
        IToken char_literal231 = null;
        GxcParser.statement_return statement225 = default(GxcParser.statement_return);

        GxcParser.constant_expression_return constant_expression227 = default(GxcParser.constant_expression_return);

        GxcParser.statement_return statement229 = default(GxcParser.statement_return);

        GxcParser.statement_return statement232 = default(GxcParser.statement_return);


        CommonTree IDENTIFIER223_tree=null;
        CommonTree char_literal224_tree=null;
        CommonTree string_literal226_tree=null;
        CommonTree char_literal228_tree=null;
        CommonTree string_literal230_tree=null;
        CommonTree char_literal231_tree=null;
        RewriteRuleTokenStream stream_94 = new RewriteRuleTokenStream(adaptor,"token 94");
        RewriteRuleTokenStream stream_93 = new RewriteRuleTokenStream(adaptor,"token 93");
        RewriteRuleTokenStream stream_80 = new RewriteRuleTokenStream(adaptor,"token 80");
        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor,"rule statement");
        RewriteRuleSubtreeStream stream_constant_expression = new RewriteRuleSubtreeStream(adaptor,"rule constant_expression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 42) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:329:2: ( IDENTIFIER ':' statement | 'case' constant_expression ':' statement -> ^( CASE constant_expression ^( CODE_BLOCK ) ( statement )? ) | 'default' ':' statement -> ^( DEFAULT_CASE ^( CODE_BLOCK ) ( statement )? ) )
            int alt47 = 3;
            switch ( input.LA(1) ) 
            {
            case IDENTIFIER:
            	{
                alt47 = 1;
                }
                break;
            case 93:
            	{
                alt47 = 2;
                }
                break;
            case 94:
            	{
                alt47 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d47s0 =
            	        new NoViableAltException("", 47, 0, input);

            	    throw nvae_d47s0;
            }

            switch (alt47) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:329:4: IDENTIFIER ':' statement
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	IDENTIFIER223=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_labeled_statement1698); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{IDENTIFIER223_tree = (CommonTree)adaptor.Create(IDENTIFIER223);
                    		adaptor.AddChild(root_0, IDENTIFIER223_tree);
                    	}
                    	char_literal224=(IToken)Match(input,80,FOLLOW_80_in_labeled_statement1700); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal224_tree = (CommonTree)adaptor.Create(char_literal224);
                    		adaptor.AddChild(root_0, char_literal224_tree);
                    	}
                    	PushFollow(FOLLOW_statement_in_labeled_statement1702);
                    	statement225 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement225.Tree);

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:330:4: 'case' constant_expression ':' statement
                    {
                    	string_literal226=(IToken)Match(input,93,FOLLOW_93_in_labeled_statement1708); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_93.Add(string_literal226);

                    	if ( (state.backtracking==0) )
                    	{
                    	  CyclomaticComplexity++;IncrementOperatorCount("case");
                    	}
                    	PushFollow(FOLLOW_constant_expression_in_labeled_statement1711);
                    	constant_expression227 = constant_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_constant_expression.Add(constant_expression227.Tree);
                    	char_literal228=(IToken)Match(input,80,FOLLOW_80_in_labeled_statement1713); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_80.Add(char_literal228);

                    	PushFollow(FOLLOW_statement_in_labeled_statement1715);
                    	statement229 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement229.Tree);


                    	// AST REWRITE
                    	// elements:          constant_expression, statement
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 330:103: -> ^( CASE constant_expression ^( CODE_BLOCK ) ( statement )? )
                    	{
                    	    // GxcGrammer\\Gxc.g:330:106: ^( CASE constant_expression ^( CODE_BLOCK ) ( statement )? )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CASE, "CASE"), root_1);

                    	    adaptor.AddChild(root_1, stream_constant_expression.NextTree());
                    	    // GxcGrammer\\Gxc.g:330:133: ^( CODE_BLOCK )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CODE_BLOCK, "CODE_BLOCK"), root_2);

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    // GxcGrammer\\Gxc.g:330:147: ( statement )?
                    	    if ( stream_statement.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_1, stream_statement.NextTree());

                    	    }
                    	    stream_statement.Reset();

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:331:4: 'default' ':' statement
                    {
                    	string_literal230=(IToken)Match(input,94,FOLLOW_94_in_labeled_statement1737); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_94.Add(string_literal230);

                    	if ( (state.backtracking==0) )
                    	{
                    	  CyclomaticComplexity++;IncrementOperatorCount("default");
                    	}
                    	char_literal231=(IToken)Match(input,80,FOLLOW_80_in_labeled_statement1740); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_80.Add(char_literal231);

                    	PushFollow(FOLLOW_statement_in_labeled_statement1742);
                    	statement232 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement232.Tree);


                    	// AST REWRITE
                    	// elements:          statement
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 331:86: -> ^( DEFAULT_CASE ^( CODE_BLOCK ) ( statement )? )
                    	{
                    	    // GxcGrammer\\Gxc.g:331:89: ^( DEFAULT_CASE ^( CODE_BLOCK ) ( statement )? )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(DEFAULT_CASE, "DEFAULT_CASE"), root_1);

                    	    // GxcGrammer\\Gxc.g:331:104: ^( CODE_BLOCK )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CODE_BLOCK, "CODE_BLOCK"), root_2);

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    // GxcGrammer\\Gxc.g:331:118: ( statement )?
                    	    if ( stream_statement.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_1, stream_statement.NextTree());

                    	    }
                    	    stream_statement.Reset();

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 42, labeled_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "labeled_statement"

    public class compound_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "compound_statement"
    // GxcGrammer\\Gxc.g:334:1: compound_statement : '{' ( declaration )* ( statement_list )? '}' ;
    public GxcParser.compound_statement_return compound_statement() // throws RecognitionException [1]
    {   
        Symbols_stack.Push(new Symbols_scope());

        GxcParser.compound_statement_return retval = new GxcParser.compound_statement_return();
        retval.Start = input.LT(1);
        int compound_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal233 = null;
        IToken char_literal236 = null;
        GxcParser.declaration_return declaration234 = default(GxcParser.declaration_return);

        GxcParser.statement_list_return statement_list235 = default(GxcParser.statement_list_return);


        CommonTree char_literal233_tree=null;
        CommonTree char_literal236_tree=null;


          ((Symbols_scope)Symbols_stack.Peek()).types =  new HashSet<string>();

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 43) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:339:2: ( '{' ( declaration )* ( statement_list )? '}' )
            // GxcGrammer\\Gxc.g:339:4: '{' ( declaration )* ( statement_list )? '}'
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	char_literal233=(IToken)Match(input,95,FOLLOW_95_in_compound_statement1776); if (state.failed) return retval;
            	// GxcGrammer\\Gxc.g:339:9: ( declaration )*
            	do 
            	{
            	    int alt48 = 2;
            	    alt48 = dfa48.Predict(input);
            	    switch (alt48) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: declaration
            			    {
            			    	PushFollow(FOLLOW_declaration_in_compound_statement1779);
            			    	declaration234 = declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, declaration234.Tree);

            			    }
            			    break;

            			default:
            			    goto loop48;
            	    }
            	} while (true);

            	loop48:
            		;	// Stops C# compiler whining that label 'loop48' has no statements

            	// GxcGrammer\\Gxc.g:339:22: ( statement_list )?
            	int alt49 = 2;
            	alt49 = dfa49.Predict(input);
            	switch (alt49) 
            	{
            	    case 1 :
            	        // GxcGrammer\\Gxc.g:0:0: statement_list
            	        {
            	        	PushFollow(FOLLOW_statement_list_in_compound_statement1782);
            	        	statement_list235 = statement_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_list235.Tree);

            	        }
            	        break;

            	}

            	char_literal236=(IToken)Match(input,96,FOLLOW_96_in_compound_statement1785); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 43, compound_statement_StartIndex); 
            }
            Symbols_stack.Pop();

        }
        return retval;
    }
    // $ANTLR end "compound_statement"

    public class statement_list_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "statement_list"
    // GxcGrammer\\Gxc.g:342:1: statement_list : ( statement )+ ;
    public GxcParser.statement_list_return statement_list() // throws RecognitionException [1]
    {   
        GxcParser.statement_list_return retval = new GxcParser.statement_list_return();
        retval.Start = input.LT(1);
        int statement_list_StartIndex = input.Index();
        CommonTree root_0 = null;

        GxcParser.statement_return statement237 = default(GxcParser.statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 44) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:343:2: ( ( statement )+ )
            // GxcGrammer\\Gxc.g:343:4: ( statement )+
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// GxcGrammer\\Gxc.g:343:4: ( statement )+
            	int cnt50 = 0;
            	do 
            	{
            	    int alt50 = 2;
            	    alt50 = dfa50.Predict(input);
            	    switch (alt50) 
            		{
            			case 1 :
            			    // GxcGrammer\\Gxc.g:0:0: statement
            			    {
            			    	PushFollow(FOLLOW_statement_in_statement_list1797);
            			    	statement237 = statement();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement237.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt50 >= 1 ) goto loop50;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee50 =
            		                new EarlyExitException(50, input);
            		            throw eee50;
            	    }
            	    cnt50++;
            	} while (true);

            	loop50:
            		;	// Stops C# compiler whining that label 'loop50' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 44, statement_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement_list"

    public class expression_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expression_statement"
    // GxcGrammer\\Gxc.g:346:1: expression_statement : ( ';' | expression ';' );
    public GxcParser.expression_statement_return expression_statement() // throws RecognitionException [1]
    {   
        GxcParser.expression_statement_return retval = new GxcParser.expression_statement_return();
        retval.Start = input.LT(1);
        int expression_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken char_literal238 = null;
        IToken char_literal240 = null;
        GxcParser.expression_return expression239 = default(GxcParser.expression_return);


        CommonTree char_literal238_tree=null;
        CommonTree char_literal240_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 45) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:347:2: ( ';' | expression ';' )
            int alt51 = 2;
            alt51 = dfa51.Predict(input);
            switch (alt51) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:347:4: ';'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal238=(IToken)Match(input,48,FOLLOW_48_in_expression_statement1809); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:348:4: expression ';'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_expression_statement1815);
                    	expression239 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression239.Tree);
                    	char_literal240=(IToken)Match(input,48,FOLLOW_48_in_expression_statement1817); if (state.failed) return retval;

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 45, expression_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression_statement"

    public class selection_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "selection_statement"
    // GxcGrammer\\Gxc.g:351:1: selection_statement : ( IF '(' expression ')' s1= statement ( options {k=1; backtrack=false; } : ELSE s2= statement -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) ) | -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1) )? | SWITCH '(' expression ')' statement -> ^( SWITCH ^( CONDITIONAL_EXPRESSION expression ) statement ) );
    public GxcParser.selection_statement_return selection_statement() // throws RecognitionException [1]
    {   
        GxcParser.selection_statement_return retval = new GxcParser.selection_statement_return();
        retval.Start = input.LT(1);
        int selection_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken IF241 = null;
        IToken char_literal242 = null;
        IToken char_literal244 = null;
        IToken ELSE245 = null;
        IToken SWITCH246 = null;
        IToken char_literal247 = null;
        IToken char_literal249 = null;
        GxcParser.statement_return s1 = default(GxcParser.statement_return);

        GxcParser.statement_return s2 = default(GxcParser.statement_return);

        GxcParser.expression_return expression243 = default(GxcParser.expression_return);

        GxcParser.expression_return expression248 = default(GxcParser.expression_return);

        GxcParser.statement_return statement250 = default(GxcParser.statement_return);


        CommonTree IF241_tree=null;
        CommonTree char_literal242_tree=null;
        CommonTree char_literal244_tree=null;
        CommonTree ELSE245_tree=null;
        CommonTree SWITCH246_tree=null;
        CommonTree char_literal247_tree=null;
        CommonTree char_literal249_tree=null;
        RewriteRuleTokenStream stream_49 = new RewriteRuleTokenStream(adaptor,"token 49");
        RewriteRuleTokenStream stream_SWITCH = new RewriteRuleTokenStream(adaptor,"token SWITCH");
        RewriteRuleTokenStream stream_IF = new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleTokenStream stream_ELSE = new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleTokenStream stream_50 = new RewriteRuleTokenStream(adaptor,"token 50");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor,"rule statement");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 46) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:352:2: ( IF '(' expression ')' s1= statement ( options {k=1; backtrack=false; } : ELSE s2= statement -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) ) | -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1) )? | SWITCH '(' expression ')' statement -> ^( SWITCH ^( CONDITIONAL_EXPRESSION expression ) statement ) )
            int alt53 = 2;
            int LA53_0 = input.LA(1);

            if ( (LA53_0 == IF) )
            {
                alt53 = 1;
            }
            else if ( (LA53_0 == SWITCH) )
            {
                alt53 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d53s0 =
                    new NoViableAltException("", 53, 0, input);

                throw nvae_d53s0;
            }
            switch (alt53) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:352:4: IF '(' expression ')' s1= statement ( options {k=1; backtrack=false; } : ELSE s2= statement -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) ) | -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1) )?
                    {
                    	IF241=(IToken)Match(input,IF,FOLLOW_IF_in_selection_statement1830); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_IF.Add(IF241);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("if");
                    	}
                    	char_literal242=(IToken)Match(input,49,FOLLOW_49_in_selection_statement1835); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal242);

                    	PushFollow(FOLLOW_expression_in_selection_statement1837);
                    	expression243 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression243.Tree);
                    	char_literal244=(IToken)Match(input,50,FOLLOW_50_in_selection_statement1839); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal244);

                    	PushFollow(FOLLOW_statement_in_selection_statement1843);
                    	s1 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(s1.Tree);
                    	// GxcGrammer\\Gxc.g:353:5: ( options {k=1; backtrack=false; } : ELSE s2= statement -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) ) | -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1) )?
                    	int alt52 = 3;
                    	int LA52_0 = input.LA(1);

                    	if ( ((LA52_0 >= STRING_LITERAL && LA52_0 <= IF) || (LA52_0 >= SWITCH && LA52_0 <= COMMENT) || (LA52_0 >= 48 && LA52_0 <= 49) || (LA52_0 >= 58 && LA52_0 <= 60) || (LA52_0 >= 63 && LA52_0 <= 68) || (LA52_0 >= 93 && LA52_0 <= 97)) )
                    	{
                    	    int LA52_1 = input.LA(2);

                    	    if ( (true) )
                    	    {
                    	        alt52 = 2;
                    	    }
                    	}
                    	else if ( (LA52_0 == ELSE) )
                    	{
                    	    int LA52_4 = input.LA(2);

                    	    if ( (true) )
                    	    {
                    	        alt52 = 1;
                    	    }
                    	    else if ( (true) )
                    	    {
                    	        alt52 = 2;
                    	    }
                    	}
                    	switch (alt52) 
                    	{
                    	    case 1 :
                    	        // GxcGrammer\\Gxc.g:353:38: ELSE s2= statement
                    	        {
                    	        	ELSE245=(IToken)Match(input,ELSE,FOLLOW_ELSE_in_selection_statement1863); if (state.failed) return retval; 
                    	        	if ( (state.backtracking==0) ) stream_ELSE.Add(ELSE245);

                    	        	if ( (state.backtracking==0) )
                    	        	{
                    	        	  IncrementOperatorCount("else");
                    	        	}
                    	        	PushFollow(FOLLOW_statement_in_selection_statement1870);
                    	        	s2 = statement();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( (state.backtracking==0) ) stream_statement.Add(s2.Tree);


                    	        	// AST REWRITE
                    	        	// elements:          s1, expression, IF, s2, ELSE
                    	        	// token labels:      
                    	        	// rule labels:       retval, s2, s1
                    	        	// token list labels: 
                    	        	// rule list labels:  
                    	        	// wildcard labels: 
                    	        	if ( (state.backtracking==0) ) {
                    	        	retval.Tree = root_0;
                    	        	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	        	RewriteRuleSubtreeStream stream_s2 = new RewriteRuleSubtreeStream(adaptor, "rule s2", s2!=null ? s2.Tree : null);
                    	        	RewriteRuleSubtreeStream stream_s1 = new RewriteRuleSubtreeStream(adaptor, "rule s1", s1!=null ? s1.Tree : null);

                    	        	root_0 = (CommonTree)adaptor.GetNilNode();
                    	        	// 353:91: -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) )
                    	        	{
                    	        	    // GxcGrammer\\Gxc.g:353:94: ^( IF ^( CONDITIONAL_EXPRESSION expression ) ^( CODE_BLOCK $s1) ^( ELSE ^( CODE_BLOCK $s2) ) )
                    	        	    {
                    	        	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_IF.NextNode(), root_1);

                    	        	    // GxcGrammer\\Gxc.g:353:99: ^( CONDITIONAL_EXPRESSION expression )
                    	        	    {
                    	        	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	        	    adaptor.AddChild(root_2, stream_expression.NextTree());

                    	        	    adaptor.AddChild(root_1, root_2);
                    	        	    }
                    	        	    // GxcGrammer\\Gxc.g:353:136: ^( CODE_BLOCK $s1)
                    	        	    {
                    	        	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CODE_BLOCK, "CODE_BLOCK"), root_2);

                    	        	    adaptor.AddChild(root_2, stream_s1.NextTree());

                    	        	    adaptor.AddChild(root_1, root_2);
                    	        	    }
                    	        	    // GxcGrammer\\Gxc.g:353:154: ^( ELSE ^( CODE_BLOCK $s2) )
                    	        	    {
                    	        	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_2 = (CommonTree)adaptor.BecomeRoot(stream_ELSE.NextNode(), root_2);

                    	        	    // GxcGrammer\\Gxc.g:353:161: ^( CODE_BLOCK $s2)
                    	        	    {
                    	        	    CommonTree root_3 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_3 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CODE_BLOCK, "CODE_BLOCK"), root_3);

                    	        	    adaptor.AddChild(root_3, stream_s2.NextTree());

                    	        	    adaptor.AddChild(root_2, root_3);
                    	        	    }

                    	        	    adaptor.AddChild(root_1, root_2);
                    	        	    }

                    	        	    adaptor.AddChild(root_0, root_1);
                    	        	    }

                    	        	}

                    	        	retval.Tree = root_0;retval.Tree = root_0;}
                    	        }
                    	        break;
                    	    case 2 :
                    	        // GxcGrammer\\Gxc.g:354:7: 
                    	        {

                    	        	// AST REWRITE
                    	        	// elements:          IF, s1, expression
                    	        	// token labels:      
                    	        	// rule labels:       retval, s1
                    	        	// token list labels: 
                    	        	// rule list labels:  
                    	        	// wildcard labels: 
                    	        	if ( (state.backtracking==0) ) {
                    	        	retval.Tree = root_0;
                    	        	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	        	RewriteRuleSubtreeStream stream_s1 = new RewriteRuleSubtreeStream(adaptor, "rule s1", s1!=null ? s1.Tree : null);

                    	        	root_0 = (CommonTree)adaptor.GetNilNode();
                    	        	// 354:7: -> ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1)
                    	        	{
                    	        	    // GxcGrammer\\Gxc.g:354:10: ^( IF ^( CONDITIONAL_EXPRESSION expression ) $s1)
                    	        	    {
                    	        	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_IF.NextNode(), root_1);

                    	        	    // GxcGrammer\\Gxc.g:354:15: ^( CONDITIONAL_EXPRESSION expression )
                    	        	    {
                    	        	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	        	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	        	    adaptor.AddChild(root_2, stream_expression.NextTree());

                    	        	    adaptor.AddChild(root_1, root_2);
                    	        	    }
                    	        	    adaptor.AddChild(root_1, stream_s1.NextTree());

                    	        	    adaptor.AddChild(root_0, root_1);
                    	        	    }

                    	        	}

                    	        	retval.Tree = root_0;retval.Tree = root_0;}
                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:355:4: SWITCH '(' expression ')' statement
                    {
                    	SWITCH246=(IToken)Match(input,SWITCH,FOLLOW_SWITCH_in_selection_statement1933); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_SWITCH.Add(SWITCH246);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("switch");
                    	}
                    	char_literal247=(IToken)Match(input,49,FOLLOW_49_in_selection_statement1939); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal247);

                    	PushFollow(FOLLOW_expression_in_selection_statement1941);
                    	expression248 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression248.Tree);
                    	char_literal249=(IToken)Match(input,50,FOLLOW_50_in_selection_statement1943); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal249);

                    	PushFollow(FOLLOW_statement_in_selection_statement1945);
                    	statement250 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement250.Tree);


                    	// AST REWRITE
                    	// elements:          expression, statement, SWITCH
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 355:81: -> ^( SWITCH ^( CONDITIONAL_EXPRESSION expression ) statement )
                    	{
                    	    // GxcGrammer\\Gxc.g:355:84: ^( SWITCH ^( CONDITIONAL_EXPRESSION expression ) statement )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_SWITCH.NextNode(), root_1);

                    	    // GxcGrammer\\Gxc.g:355:93: ^( CONDITIONAL_EXPRESSION expression )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	    adaptor.AddChild(root_2, stream_expression.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, stream_statement.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 46, selection_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "selection_statement"

    public class iteration_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "iteration_statement"
    // GxcGrammer\\Gxc.g:358:1: iteration_statement : ( WHILE '(' expression ')' statement -> ^( WHILE ^( CONDITIONAL_EXPRESSION ^( expression statement ) ) ) | DO statement WHILE '(' expression ')' ';' -> ^( DO statement ^( CONDITIONAL_EXPRESSION expression ) ) | FOR '(' init= expression_statement cond= expression_statement (inc= expression )? ')' statement -> ^( FOR $init ^( CONDITIONAL_EXPRESSION ^( $cond statement ) ) ( $inc)? ) );
    public GxcParser.iteration_statement_return iteration_statement() // throws RecognitionException [1]
    {   
        GxcParser.iteration_statement_return retval = new GxcParser.iteration_statement_return();
        retval.Start = input.LT(1);
        int iteration_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken WHILE251 = null;
        IToken char_literal252 = null;
        IToken char_literal254 = null;
        IToken DO256 = null;
        IToken WHILE258 = null;
        IToken char_literal259 = null;
        IToken char_literal261 = null;
        IToken char_literal262 = null;
        IToken FOR263 = null;
        IToken char_literal264 = null;
        IToken char_literal265 = null;
        GxcParser.expression_statement_return init = default(GxcParser.expression_statement_return);

        GxcParser.expression_statement_return cond = default(GxcParser.expression_statement_return);

        GxcParser.expression_return inc = default(GxcParser.expression_return);

        GxcParser.expression_return expression253 = default(GxcParser.expression_return);

        GxcParser.statement_return statement255 = default(GxcParser.statement_return);

        GxcParser.statement_return statement257 = default(GxcParser.statement_return);

        GxcParser.expression_return expression260 = default(GxcParser.expression_return);

        GxcParser.statement_return statement266 = default(GxcParser.statement_return);


        CommonTree WHILE251_tree=null;
        CommonTree char_literal252_tree=null;
        CommonTree char_literal254_tree=null;
        CommonTree DO256_tree=null;
        CommonTree WHILE258_tree=null;
        CommonTree char_literal259_tree=null;
        CommonTree char_literal261_tree=null;
        CommonTree char_literal262_tree=null;
        CommonTree FOR263_tree=null;
        CommonTree char_literal264_tree=null;
        CommonTree char_literal265_tree=null;
        RewriteRuleTokenStream stream_49 = new RewriteRuleTokenStream(adaptor,"token 49");
        RewriteRuleTokenStream stream_48 = new RewriteRuleTokenStream(adaptor,"token 48");
        RewriteRuleTokenStream stream_FOR = new RewriteRuleTokenStream(adaptor,"token FOR");
        RewriteRuleTokenStream stream_DO = new RewriteRuleTokenStream(adaptor,"token DO");
        RewriteRuleTokenStream stream_WHILE = new RewriteRuleTokenStream(adaptor,"token WHILE");
        RewriteRuleTokenStream stream_50 = new RewriteRuleTokenStream(adaptor,"token 50");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor,"rule statement");
        RewriteRuleSubtreeStream stream_expression_statement = new RewriteRuleSubtreeStream(adaptor,"rule expression_statement");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 47) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:359:2: ( WHILE '(' expression ')' statement -> ^( WHILE ^( CONDITIONAL_EXPRESSION ^( expression statement ) ) ) | DO statement WHILE '(' expression ')' ';' -> ^( DO statement ^( CONDITIONAL_EXPRESSION expression ) ) | FOR '(' init= expression_statement cond= expression_statement (inc= expression )? ')' statement -> ^( FOR $init ^( CONDITIONAL_EXPRESSION ^( $cond statement ) ) ( $inc)? ) )
            int alt55 = 3;
            switch ( input.LA(1) ) 
            {
            case WHILE:
            	{
                alt55 = 1;
                }
                break;
            case DO:
            	{
                alt55 = 2;
                }
                break;
            case FOR:
            	{
                alt55 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d55s0 =
            	        new NoViableAltException("", 55, 0, input);

            	    throw nvae_d55s0;
            }

            switch (alt55) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:359:4: WHILE '(' expression ')' statement
                    {
                    	WHILE251=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_iteration_statement1975); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_WHILE.Add(WHILE251);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("while");
                    	}
                    	char_literal252=(IToken)Match(input,49,FOLLOW_49_in_iteration_statement1979); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal252);

                    	PushFollow(FOLLOW_expression_in_iteration_statement1981);
                    	expression253 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression253.Tree);
                    	char_literal254=(IToken)Match(input,50,FOLLOW_50_in_iteration_statement1983); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal254);

                    	PushFollow(FOLLOW_statement_in_iteration_statement1985);
                    	statement255 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement255.Tree);


                    	// AST REWRITE
                    	// elements:          statement, expression, WHILE
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 359:74: -> ^( WHILE ^( CONDITIONAL_EXPRESSION ^( expression statement ) ) )
                    	{
                    	    // GxcGrammer\\Gxc.g:359:77: ^( WHILE ^( CONDITIONAL_EXPRESSION ^( expression statement ) ) )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_WHILE.NextNode(), root_1);

                    	    // GxcGrammer\\Gxc.g:359:85: ^( CONDITIONAL_EXPRESSION ^( expression statement ) )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	    // GxcGrammer\\Gxc.g:359:110: ^( expression statement )
                    	    {
                    	    CommonTree root_3 = (CommonTree)adaptor.GetNilNode();
                    	    root_3 = (CommonTree)adaptor.BecomeRoot(stream_expression.NextNode(), root_3);

                    	    adaptor.AddChild(root_3, stream_statement.NextTree());

                    	    adaptor.AddChild(root_2, root_3);
                    	    }

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:360:4: DO statement WHILE '(' expression ')' ';'
                    {
                    	DO256=(IToken)Match(input,DO,FOLLOW_DO_in_iteration_statement2008); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_DO.Add(DO256);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("do");
                    	}
                    	PushFollow(FOLLOW_statement_in_iteration_statement2012);
                    	statement257 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement257.Tree);
                    	WHILE258=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_iteration_statement2014); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_WHILE.Add(WHILE258);

                    	char_literal259=(IToken)Match(input,49,FOLLOW_49_in_iteration_statement2016); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal259);

                    	PushFollow(FOLLOW_expression_in_iteration_statement2018);
                    	expression260 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression260.Tree);
                    	char_literal261=(IToken)Match(input,50,FOLLOW_50_in_iteration_statement2020); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal261);

                    	char_literal262=(IToken)Match(input,48,FOLLOW_48_in_iteration_statement2022); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_48.Add(char_literal262);



                    	// AST REWRITE
                    	// elements:          DO, expression, statement
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 360:78: -> ^( DO statement ^( CONDITIONAL_EXPRESSION expression ) )
                    	{
                    	    // GxcGrammer\\Gxc.g:360:80: ^( DO statement ^( CONDITIONAL_EXPRESSION expression ) )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_DO.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_statement.NextTree());
                    	    // GxcGrammer\\Gxc.g:360:95: ^( CONDITIONAL_EXPRESSION expression )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	    adaptor.AddChild(root_2, stream_expression.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:361:4: FOR '(' init= expression_statement cond= expression_statement (inc= expression )? ')' statement
                    {
                    	FOR263=(IToken)Match(input,FOR,FOLLOW_FOR_in_iteration_statement2040); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_FOR.Add(FOR263);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("for");
                    	}
                    	char_literal264=(IToken)Match(input,49,FOLLOW_49_in_iteration_statement2044); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_49.Add(char_literal264);

                    	PushFollow(FOLLOW_expression_statement_in_iteration_statement2048);
                    	init = expression_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression_statement.Add(init.Tree);
                    	PushFollow(FOLLOW_expression_statement_in_iteration_statement2052);
                    	cond = expression_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression_statement.Add(cond.Tree);
                    	// GxcGrammer\\Gxc.g:361:101: (inc= expression )?
                    	int alt54 = 2;
                    	alt54 = dfa54.Predict(input);
                    	switch (alt54) 
                    	{
                    	    case 1 :
                    	        // GxcGrammer\\Gxc.g:0:0: inc= expression
                    	        {
                    	        	PushFollow(FOLLOW_expression_in_iteration_statement2058);
                    	        	inc = expression();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( (state.backtracking==0) ) stream_expression.Add(inc.Tree);

                    	        }
                    	        break;

                    	}

                    	char_literal265=(IToken)Match(input,50,FOLLOW_50_in_iteration_statement2061); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_50.Add(char_literal265);

                    	PushFollow(FOLLOW_statement_in_iteration_statement2063);
                    	statement266 = statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_statement.Add(statement266.Tree);


                    	// AST REWRITE
                    	// elements:          init, cond, FOR, statement, inc
                    	// token labels:      
                    	// rule labels:       retval, inc, init, cond
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
                    	RewriteRuleSubtreeStream stream_inc = new RewriteRuleSubtreeStream(adaptor, "rule inc", inc!=null ? inc.Tree : null);
                    	RewriteRuleSubtreeStream stream_init = new RewriteRuleSubtreeStream(adaptor, "rule init", init!=null ? init.Tree : null);
                    	RewriteRuleSubtreeStream stream_cond = new RewriteRuleSubtreeStream(adaptor, "rule cond", cond!=null ? cond.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 361:129: -> ^( FOR $init ^( CONDITIONAL_EXPRESSION ^( $cond statement ) ) ( $inc)? )
                    	{
                    	    // GxcGrammer\\Gxc.g:361:132: ^( FOR $init ^( CONDITIONAL_EXPRESSION ^( $cond statement ) ) ( $inc)? )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_FOR.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_init.NextTree());
                    	    // GxcGrammer\\Gxc.g:361:144: ^( CONDITIONAL_EXPRESSION ^( $cond statement ) )
                    	    {
                    	    CommonTree root_2 = (CommonTree)adaptor.GetNilNode();
                    	    root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITIONAL_EXPRESSION, "CONDITIONAL_EXPRESSION"), root_2);

                    	    // GxcGrammer\\Gxc.g:361:169: ^( $cond statement )
                    	    {
                    	    CommonTree root_3 = (CommonTree)adaptor.GetNilNode();
                    	    root_3 = (CommonTree)adaptor.BecomeRoot(stream_cond.NextNode(), root_3);

                    	    adaptor.AddChild(root_3, stream_statement.NextTree());

                    	    adaptor.AddChild(root_2, root_3);
                    	    }

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    // GxcGrammer\\Gxc.g:361:189: ( $inc)?
                    	    if ( stream_inc.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_1, stream_inc.NextTree());

                    	    }
                    	    stream_inc.Reset();

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 47, iteration_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "iteration_statement"

    public class jump_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "jump_statement"
    // GxcGrammer\\Gxc.g:364:1: jump_statement : ( 'goto' IDENTIFIER ';' | CONTINUE ';' -> ^( CONTINUE ) | BREAK ';' -> ^( BREAK ) );
    public GxcParser.jump_statement_return jump_statement() // throws RecognitionException [1]
    {   
        GxcParser.jump_statement_return retval = new GxcParser.jump_statement_return();
        retval.Start = input.LT(1);
        int jump_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal267 = null;
        IToken IDENTIFIER268 = null;
        IToken char_literal269 = null;
        IToken CONTINUE270 = null;
        IToken char_literal271 = null;
        IToken BREAK272 = null;
        IToken char_literal273 = null;

        CommonTree string_literal267_tree=null;
        CommonTree IDENTIFIER268_tree=null;
        CommonTree char_literal269_tree=null;
        CommonTree CONTINUE270_tree=null;
        CommonTree char_literal271_tree=null;
        CommonTree BREAK272_tree=null;
        CommonTree char_literal273_tree=null;
        RewriteRuleTokenStream stream_48 = new RewriteRuleTokenStream(adaptor,"token 48");
        RewriteRuleTokenStream stream_CONTINUE = new RewriteRuleTokenStream(adaptor,"token CONTINUE");
        RewriteRuleTokenStream stream_BREAK = new RewriteRuleTokenStream(adaptor,"token BREAK");

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 48) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:365:2: ( 'goto' IDENTIFIER ';' | CONTINUE ';' -> ^( CONTINUE ) | BREAK ';' -> ^( BREAK ) )
            int alt56 = 3;
            switch ( input.LA(1) ) 
            {
            case 97:
            	{
                alt56 = 1;
                }
                break;
            case CONTINUE:
            	{
                alt56 = 2;
                }
                break;
            case BREAK:
            	{
                alt56 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d56s0 =
            	        new NoViableAltException("", 56, 0, input);

            	    throw nvae_d56s0;
            }

            switch (alt56) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:365:4: 'goto' IDENTIFIER ';'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	string_literal267=(IToken)Match(input,97,FOLLOW_97_in_jump_statement2098); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal267_tree = (CommonTree)adaptor.Create(string_literal267);
                    		adaptor.AddChild(root_0, string_literal267_tree);
                    	}
                    	IDENTIFIER268=(IToken)Match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_jump_statement2100); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{IDENTIFIER268_tree = (CommonTree)adaptor.Create(IDENTIFIER268);
                    		adaptor.AddChild(root_0, IDENTIFIER268_tree);
                    	}
                    	char_literal269=(IToken)Match(input,48,FOLLOW_48_in_jump_statement2102); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:366:4: CONTINUE ';'
                    {
                    	CONTINUE270=(IToken)Match(input,CONTINUE,FOLLOW_CONTINUE_in_jump_statement2108); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_CONTINUE.Add(CONTINUE270);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("continue");
                    	}
                    	char_literal271=(IToken)Match(input,48,FOLLOW_48_in_jump_statement2113); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_48.Add(char_literal271);



                    	// AST REWRITE
                    	// elements:          CONTINUE
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 366:56: -> ^( CONTINUE )
                    	{
                    	    // GxcGrammer\\Gxc.g:366:59: ^( CONTINUE )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_CONTINUE.NextNode(), root_1);

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // GxcGrammer\\Gxc.g:367:4: BREAK ';'
                    {
                    	BREAK272=(IToken)Match(input,BREAK,FOLLOW_BREAK_in_jump_statement2124); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_BREAK.Add(BREAK272);

                    	if ( (state.backtracking==0) )
                    	{
                    	  IncrementOperatorCount("break");
                    	}
                    	char_literal273=(IToken)Match(input,48,FOLLOW_48_in_jump_statement2128); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_48.Add(char_literal273);



                    	// AST REWRITE
                    	// elements:          BREAK
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 367:50: -> ^( BREAK )
                    	{
                    	    // GxcGrammer\\Gxc.g:367:53: ^( BREAK )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_BREAK.NextNode(), root_1);

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 48, jump_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "jump_statement"

    public class comment_statement_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "comment_statement"
    // GxcGrammer\\Gxc.g:370:1: comment_statement : ( LINE_COMMENT | COMMENT );
    public GxcParser.comment_statement_return comment_statement() // throws RecognitionException [1]
    {   
        GxcParser.comment_statement_return retval = new GxcParser.comment_statement_return();
        retval.Start = input.LT(1);
        int comment_statement_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken LINE_COMMENT274 = null;
        IToken COMMENT275 = null;

        CommonTree LINE_COMMENT274_tree=null;
        CommonTree COMMENT275_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 49) ) 
    	    {
    	    	return retval; 
    	    }
            // GxcGrammer\\Gxc.g:371:4: ( LINE_COMMENT | COMMENT )
            int alt57 = 2;
            int LA57_0 = input.LA(1);

            if ( (LA57_0 == LINE_COMMENT) )
            {
                alt57 = 1;
            }
            else if ( (LA57_0 == COMMENT) )
            {
                alt57 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d57s0 =
                    new NoViableAltException("", 57, 0, input);

                throw nvae_d57s0;
            }
            switch (alt57) 
            {
                case 1 :
                    // GxcGrammer\\Gxc.g:371:5: LINE_COMMENT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	LINE_COMMENT274=(IToken)Match(input,LINE_COMMENT,FOLLOW_LINE_COMMENT_in_comment_statement2147); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{LINE_COMMENT274_tree = (CommonTree)adaptor.Create(LINE_COMMENT274);
                    		adaptor.AddChild(root_0, LINE_COMMENT274_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  LinesOfComments++;
                    	}

                    }
                    break;
                case 2 :
                    // GxcGrammer\\Gxc.g:372:5: COMMENT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	COMMENT275=(IToken)Match(input,COMMENT,FOLLOW_COMMENT_in_comment_statement2154); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{COMMENT275_tree = (CommonTree)adaptor.Create(COMMENT275);
                    		adaptor.AddChild(root_0, COMMENT275_tree);
                    	}
                    	if ( (state.backtracking==0) )
                    	{
                    	  CountBlockCommentLines(COMMENT275.Text);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 49, comment_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "comment_statement"

    // $ANTLR start "synpred7_Gxc"
    public void synpred7_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:82:3: ( function_declaration )
        // GxcGrammer\\Gxc.g:82:3: function_declaration
        {
        	PushFollow(FOLLOW_function_declaration_in_synpred7_Gxc310);
        	function_declaration();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred7_Gxc"

    // $ANTLR start "synpred46_Gxc"
    public void synpred46_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:201:4: ( '(' type_specifier ')' cast_expression )
        // GxcGrammer\\Gxc.g:201:4: '(' type_specifier ')' cast_expression
        {
        	Match(input,49,FOLLOW_49_in_synpred46_Gxc969); if (state.failed) return ;
        	PushFollow(FOLLOW_type_specifier_in_synpred46_Gxc972);
        	type_specifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,50,FOLLOW_50_in_synpred46_Gxc974); if (state.failed) return ;
        	PushFollow(FOLLOW_cast_expression_in_synpred46_Gxc977);
        	cast_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred46_Gxc"

    // $ANTLR start "synpred51_Gxc"
    public void synpred51_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:210:4: ( 'sizeof' unary_expression )
        // GxcGrammer\\Gxc.g:210:4: 'sizeof' unary_expression
        {
        	Match(input,65,FOLLOW_65_in_synpred51_Gxc1021); if (state.failed) return ;
        	PushFollow(FOLLOW_unary_expression_in_synpred51_Gxc1023);
        	unary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred51_Gxc"

    // $ANTLR start "synpred52_Gxc"
    public void synpred52_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:215:4: ( primary_expression )
        // GxcGrammer\\Gxc.g:215:4: primary_expression
        {
        	PushFollow(FOLLOW_primary_expression_in_synpred52_Gxc1047);
        	primary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred52_Gxc"

    // $ANTLR start "synpred53_Gxc"
    public void synpred53_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:216:4: ( primary_expression '[' expression ']' )
        // GxcGrammer\\Gxc.g:216:4: primary_expression '[' expression ']'
        {
        	PushFollow(FOLLOW_primary_expression_in_synpred53_Gxc1060);
        	primary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,56,FOLLOW_56_in_synpred53_Gxc1062); if (state.failed) return ;
        	PushFollow(FOLLOW_expression_in_synpred53_Gxc1064);
        	expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,57,FOLLOW_57_in_synpred53_Gxc1066); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred53_Gxc"

    // $ANTLR start "synpred54_Gxc"
    public void synpred54_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:217:4: ( primary_expression '++' )
        // GxcGrammer\\Gxc.g:217:4: primary_expression '++'
        {
        	PushFollow(FOLLOW_primary_expression_in_synpred54_Gxc1073);
        	primary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,63,FOLLOW_63_in_synpred54_Gxc1075); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred54_Gxc"

    // $ANTLR start "synpred55_Gxc"
    public void synpred55_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:218:4: ( primary_expression '--' )
        // GxcGrammer\\Gxc.g:218:4: primary_expression '--'
        {
        	PushFollow(FOLLOW_primary_expression_in_synpred55_Gxc1095);
        	primary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,64,FOLLOW_64_in_synpred55_Gxc1097); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred55_Gxc"

    // $ANTLR start "synpred71_Gxc"
    public void synpred71_Gxc_fragment() {
        // GxcGrammer\\Gxc.g:258:4: ( lvalue assignment_operator assignment_expression )
        // GxcGrammer\\Gxc.g:258:4: lvalue assignment_operator assignment_expression
        {
        	PushFollow(FOLLOW_lvalue_in_synpred71_Gxc1333);
        	lvalue();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	PushFollow(FOLLOW_assignment_operator_in_synpred71_Gxc1335);
        	assignment_operator();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	PushFollow(FOLLOW_assignment_expression_in_synpred71_Gxc1337);
        	assignment_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred71_Gxc"

    // Delegated rules

   	public bool synpred54_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred54_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred7_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred7_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred71_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred71_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred53_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred53_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred55_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred55_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred52_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred52_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred46_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred46_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred51_Gxc() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred51_Gxc_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


   	protected DFA1 dfa1;
   	protected DFA3 dfa3;
   	protected DFA5 dfa5;
   	protected DFA10 dfa10;
   	protected DFA11 dfa11;
   	protected DFA22 dfa22;
   	protected DFA23 dfa23;
   	protected DFA24 dfa24;
   	protected DFA25 dfa25;
   	protected DFA27 dfa27;
   	protected DFA26 dfa26;
   	protected DFA29 dfa29;
   	protected DFA32 dfa32;
   	protected DFA33 dfa33;
   	protected DFA36 dfa36;
   	protected DFA37 dfa37;
   	protected DFA38 dfa38;
   	protected DFA39 dfa39;
   	protected DFA41 dfa41;
   	protected DFA43 dfa43;
   	protected DFA45 dfa45;
   	protected DFA46 dfa46;
   	protected DFA48 dfa48;
   	protected DFA49 dfa49;
   	protected DFA50 dfa50;
   	protected DFA51 dfa51;
   	protected DFA54 dfa54;
	private void InitializeCyclicDFAs()
	{
    	this.dfa1 = new DFA1(this);
    	this.dfa3 = new DFA3(this);
    	this.dfa5 = new DFA5(this);
    	this.dfa10 = new DFA10(this);
    	this.dfa11 = new DFA11(this);
    	this.dfa22 = new DFA22(this);
    	this.dfa23 = new DFA23(this);
    	this.dfa24 = new DFA24(this);
    	this.dfa25 = new DFA25(this);
    	this.dfa27 = new DFA27(this);
    	this.dfa26 = new DFA26(this);
    	this.dfa29 = new DFA29(this);
    	this.dfa32 = new DFA32(this);
    	this.dfa33 = new DFA33(this);
    	this.dfa36 = new DFA36(this);
    	this.dfa37 = new DFA37(this);
    	this.dfa38 = new DFA38(this);
    	this.dfa39 = new DFA39(this);
    	this.dfa41 = new DFA41(this);
    	this.dfa43 = new DFA43(this);
    	this.dfa45 = new DFA45(this);
    	this.dfa46 = new DFA46(this);
    	this.dfa48 = new DFA48(this);
    	this.dfa49 = new DFA49(this);
    	this.dfa50 = new DFA50(this);
    	this.dfa51 = new DFA51(this);
    	this.dfa54 = new DFA54(this);


	    this.dfa5.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA5_SpecialStateTransition);




	    this.dfa24.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA24_SpecialStateTransition);
	    this.dfa25.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA25_SpecialStateTransition);
	    this.dfa27.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA27_SpecialStateTransition);


	    this.dfa32.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA32_SpecialStateTransition);














	}

    const string DFA1_eotS =
        "\x0c\uffff";
    const string DFA1_eofS =
        "\x0c\uffff";
    const string DFA1_minS =
        "\x01\x0e\x0b\uffff";
    const string DFA1_maxS =
        "\x01\x5f\x0b\uffff";
    const string DFA1_acceptS =
        "\x01\uffff\x01\x02\x07\uffff\x01\x01\x02\uffff";
    const string DFA1_specialS =
        "\x0c\uffff}>";
    static readonly string[] DFA1_transitionS = {
            "\x01\x01\x1a\uffff\x01\x09\x01\uffff\x02\x09\x01\uffff\x01"+
            "\x01\x04\uffff\x04\x01\x01\uffff\x01\x01\x26\uffff\x01\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA1_eot = DFA.UnpackEncodedString(DFA1_eotS);
    static readonly short[] DFA1_eof = DFA.UnpackEncodedString(DFA1_eofS);
    static readonly char[] DFA1_min = DFA.UnpackEncodedStringToUnsignedChars(DFA1_minS);
    static readonly char[] DFA1_max = DFA.UnpackEncodedStringToUnsignedChars(DFA1_maxS);
    static readonly short[] DFA1_accept = DFA.UnpackEncodedString(DFA1_acceptS);
    static readonly short[] DFA1_special = DFA.UnpackEncodedString(DFA1_specialS);
    static readonly short[][] DFA1_transition = DFA.UnpackEncodedStringArray(DFA1_transitionS);

    protected class DFA1 : DFA
    {
        public DFA1(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 1;
            this.eot = DFA1_eot;
            this.eof = DFA1_eof;
            this.min = DFA1_min;
            this.max = DFA1_max;
            this.accept = DFA1_accept;
            this.special = DFA1_special;
            this.transition = DFA1_transition;

        }

        override public string Description
        {
            get { return "()+ loopback of 58:4: ( gx_meta_declarations )+"; }
        }

    }

    const string DFA3_eotS =
        "\x0e\uffff";
    const string DFA3_eofS =
        "\x01\x01\x0d\uffff";
    const string DFA3_minS =
        "\x01\x0e\x0d\uffff";
    const string DFA3_maxS =
        "\x01\x5f\x0d\uffff";
    const string DFA3_acceptS =
        "\x01\uffff\x01\x02\x0b\uffff\x01\x01";
    const string DFA3_specialS =
        "\x0e\uffff}>";
    static readonly string[] DFA3_transitionS = {
            "\x01\x01\x1a\uffff\x01\x01\x01\uffff\x02\x01\x01\x0d\x01\x01"+
            "\x04\uffff\x04\x01\x01\uffff\x01\x01\x26\uffff\x01\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA3_eot = DFA.UnpackEncodedString(DFA3_eotS);
    static readonly short[] DFA3_eof = DFA.UnpackEncodedString(DFA3_eofS);
    static readonly char[] DFA3_min = DFA.UnpackEncodedStringToUnsignedChars(DFA3_minS);
    static readonly char[] DFA3_max = DFA.UnpackEncodedStringToUnsignedChars(DFA3_maxS);
    static readonly short[] DFA3_accept = DFA.UnpackEncodedString(DFA3_acceptS);
    static readonly short[] DFA3_special = DFA.UnpackEncodedString(DFA3_specialS);
    static readonly short[][] DFA3_transition = DFA.UnpackEncodedStringArray(DFA3_transitionS);

    protected class DFA3 : DFA
    {
        public DFA3(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 3;
            this.eot = DFA3_eot;
            this.eof = DFA3_eof;
            this.min = DFA3_min;
            this.max = DFA3_max;
            this.accept = DFA3_accept;
            this.special = DFA3_special;
            this.transition = DFA3_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 64:19: ( gx_resource )*"; }
        }

    }

    const string DFA5_eotS =
        "\x10\uffff";
    const string DFA5_eofS =
        "\x10\uffff";
    const string DFA5_minS =
        "\x01\x0e\x02\uffff\x05\x0e\x01\x00\x01\uffff\x01\x00\x01\uffff"+
        "\x01\x00\x01\uffff\x02\x00";
    const string DFA5_maxS =
        "\x01\x38\x02\uffff\x01\x0e\x03\x31\x01\x0e\x01\x00\x01\uffff\x01"+
        "\x00\x01\uffff\x01\x00\x01\uffff\x02\x00";
    const string DFA5_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x06\uffff\x01\x03\x06\uffff";
    const string DFA5_specialS =
        "\x08\uffff\x01\x00\x01\uffff\x01\x01\x01\uffff\x01\x02\x01\uffff"+
        "\x01\x03\x01\x04}>";
    static readonly string[] DFA5_transitionS = {
            "\x01\x07\x1f\uffff\x01\x01\x04\uffff\x01\x03\x01\x04\x01\x05"+
            "\x01\x06\x01\uffff\x01\x02",
            "",
            "",
            "\x01\x08",
            "\x01\x0a\x22\uffff\x01\x09",
            "\x01\x0c\x22\uffff\x01\x09",
            "\x01\x0e\x22\uffff\x01\x09",
            "\x01\x0f",
            "\x01\uffff",
            "",
            "\x01\uffff",
            "",
            "\x01\uffff",
            "",
            "\x01\uffff",
            "\x01\uffff"
    };

    static readonly short[] DFA5_eot = DFA.UnpackEncodedString(DFA5_eotS);
    static readonly short[] DFA5_eof = DFA.UnpackEncodedString(DFA5_eofS);
    static readonly char[] DFA5_min = DFA.UnpackEncodedStringToUnsignedChars(DFA5_minS);
    static readonly char[] DFA5_max = DFA.UnpackEncodedStringToUnsignedChars(DFA5_maxS);
    static readonly short[] DFA5_accept = DFA.UnpackEncodedString(DFA5_acceptS);
    static readonly short[] DFA5_special = DFA.UnpackEncodedString(DFA5_specialS);
    static readonly short[][] DFA5_transition = DFA.UnpackEncodedStringArray(DFA5_transitionS);

    protected class DFA5 : DFA
    {
        public DFA5(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 5;
            this.eot = DFA5_eot;
            this.eof = DFA5_eof;
            this.min = DFA5_min;
            this.max = DFA5_max;
            this.accept = DFA5_accept;
            this.special = DFA5_special;
            this.transition = DFA5_transition;

        }

        override public string Description
        {
            get { return "80:1: declaration : ( type_declaration | function_declaration | variable_declaration );"; }
        }

    }


    protected internal int DFA5_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA5_8 = input.LA(1);

                   	 
                   	int index5_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred7_Gxc()) ) { s = 2; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index5_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA5_10 = input.LA(1);

                   	 
                   	int index5_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred7_Gxc()) ) { s = 2; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index5_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA5_12 = input.LA(1);

                   	 
                   	int index5_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred7_Gxc()) ) { s = 2; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index5_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA5_14 = input.LA(1);

                   	 
                   	int index5_14 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred7_Gxc()) ) { s = 2; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index5_14);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA5_15 = input.LA(1);

                   	 
                   	int index5_15 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( ((synpred7_Gxc() && (isTypeName(input.LT(1).Text)))) ) { s = 2; }

                   	else if ( ((isTypeName(input.LT(1).Text))) ) { s = 9; }

                   	 
                   	input.Seek(index5_15);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae5 =
            new NoViableAltException(dfa.Description, 5, _s, input);
        dfa.Error(nvae5);
        throw nvae5;
    }
    const string DFA10_eotS =
        "\x0c\uffff";
    const string DFA10_eofS =
        "\x0c\uffff";
    const string DFA10_minS =
        "\x01\x0e\x05\uffff\x01\x0e\x05\uffff";
    const string DFA10_maxS =
        "\x01\x37\x05\uffff\x01\x36\x05\uffff";
    const string DFA10_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\uffff\x01"+
        "\x06\x01\x07\x01\x08\x01\x09\x01\x0a";
    const string DFA10_specialS =
        "\x0c\uffff}>";
    static readonly string[] DFA10_transitionS = {
            "\x01\x05\x24\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x06",
            "",
            "",
            "",
            "",
            "",
            "\x01\x0b\x24\uffff\x01\x07\x01\x08\x01\x09\x01\x0a",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA10_eot = DFA.UnpackEncodedString(DFA10_eotS);
    static readonly short[] DFA10_eof = DFA.UnpackEncodedString(DFA10_eofS);
    static readonly char[] DFA10_min = DFA.UnpackEncodedStringToUnsignedChars(DFA10_minS);
    static readonly char[] DFA10_max = DFA.UnpackEncodedStringToUnsignedChars(DFA10_maxS);
    static readonly short[] DFA10_accept = DFA.UnpackEncodedString(DFA10_acceptS);
    static readonly short[] DFA10_special = DFA.UnpackEncodedString(DFA10_specialS);
    static readonly short[][] DFA10_transition = DFA.UnpackEncodedStringArray(DFA10_transitionS);

    protected class DFA10 : DFA
    {
        public DFA10(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;

        }

        override public string Description
        {
            get { return "127:2: func_declaration_specifiers : ( 'void' | 'int' | 'real' | 'string' | type_id | 'var' 'void' | 'var' 'int' | 'var' 'real' | 'var' 'string' | 'var' type_id );"; }
        }

    }

    const string DFA11_eotS =
        "\x0a\uffff";
    const string DFA11_eofS =
        "\x01\x01\x09\uffff";
    const string DFA11_minS =
        "\x01\x0e\x09\uffff";
    const string DFA11_maxS =
        "\x01\x37\x09\uffff";
    const string DFA11_acceptS =
        "\x01\uffff\x01\x02\x07\uffff\x01\x01";
    const string DFA11_specialS =
        "\x0a\uffff}>";
    static readonly string[] DFA11_transitionS = {
            "\x01\x01\x20\uffff\x01\x09\x02\uffff\x06\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA11_eot = DFA.UnpackEncodedString(DFA11_eotS);
    static readonly short[] DFA11_eof = DFA.UnpackEncodedString(DFA11_eofS);
    static readonly char[] DFA11_min = DFA.UnpackEncodedStringToUnsignedChars(DFA11_minS);
    static readonly char[] DFA11_max = DFA.UnpackEncodedStringToUnsignedChars(DFA11_maxS);
    static readonly short[] DFA11_accept = DFA.UnpackEncodedString(DFA11_acceptS);
    static readonly short[] DFA11_special = DFA.UnpackEncodedString(DFA11_specialS);
    static readonly short[][] DFA11_transition = DFA.UnpackEncodedStringArray(DFA11_transitionS);

    protected class DFA11 : DFA
    {
        public DFA11(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = DFA11_eot;
            this.eof = DFA11_eof;
            this.min = DFA11_min;
            this.max = DFA11_max;
            this.accept = DFA11_accept;
            this.special = DFA11_special;
            this.transition = DFA11_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 146:33: ( ',' func_declaration_specifiers )*"; }
        }

    }

    const string DFA22_eotS =
        "\x17\uffff";
    const string DFA22_eofS =
        "\x01\x01\x16\uffff";
    const string DFA22_minS =
        "\x01\x2f\x16\uffff";
    const string DFA22_maxS =
        "\x01\x5c\x16\uffff";
    const string DFA22_acceptS =
        "\x01\uffff\x01\x03\x13\uffff\x01\x01\x01\x02";
    const string DFA22_specialS =
        "\x17\uffff}>";
    static readonly string[] DFA22_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x01\x15\x01\x16"+
            "\x06\uffff\x01\x01\x0c\uffff\x0e\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA22_eot = DFA.UnpackEncodedString(DFA22_eotS);
    static readonly short[] DFA22_eof = DFA.UnpackEncodedString(DFA22_eofS);
    static readonly char[] DFA22_min = DFA.UnpackEncodedStringToUnsignedChars(DFA22_minS);
    static readonly char[] DFA22_max = DFA.UnpackEncodedStringToUnsignedChars(DFA22_maxS);
    static readonly short[] DFA22_accept = DFA.UnpackEncodedString(DFA22_acceptS);
    static readonly short[] DFA22_special = DFA.UnpackEncodedString(DFA22_specialS);
    static readonly short[][] DFA22_transition = DFA.UnpackEncodedStringArray(DFA22_transitionS);

    protected class DFA22 : DFA
    {
        public DFA22(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 22;
            this.eot = DFA22_eot;
            this.eof = DFA22_eof;
            this.min = DFA22_min;
            this.max = DFA22_max;
            this.accept = DFA22_accept;
            this.special = DFA22_special;
            this.transition = DFA22_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 193:32: ( '+' multiplicative_expression | '-' multiplicative_expression )*"; }
        }

    }

    const string DFA23_eotS =
        "\x1a\uffff";
    const string DFA23_eofS =
        "\x01\x01\x19\uffff";
    const string DFA23_minS =
        "\x01\x2f\x19\uffff";
    const string DFA23_maxS =
        "\x01\x5c\x19\uffff";
    const string DFA23_acceptS =
        "\x01\uffff\x01\x04\x15\uffff\x01\x01\x01\x02\x01\x03";
    const string DFA23_specialS =
        "\x1a\uffff}>";
    static readonly string[] DFA23_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x03\x01\x01\x17\x01\x18"+
            "\x01\x19\x03\uffff\x01\x01\x0c\uffff\x0e\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA23_eot = DFA.UnpackEncodedString(DFA23_eotS);
    static readonly short[] DFA23_eof = DFA.UnpackEncodedString(DFA23_eofS);
    static readonly char[] DFA23_min = DFA.UnpackEncodedStringToUnsignedChars(DFA23_minS);
    static readonly char[] DFA23_max = DFA.UnpackEncodedStringToUnsignedChars(DFA23_maxS);
    static readonly short[] DFA23_accept = DFA.UnpackEncodedString(DFA23_acceptS);
    static readonly short[] DFA23_special = DFA.UnpackEncodedString(DFA23_specialS);
    static readonly short[][] DFA23_transition = DFA.UnpackEncodedStringArray(DFA23_transitionS);

    protected class DFA23 : DFA
    {
        public DFA23(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 23;
            this.eot = DFA23_eot;
            this.eof = DFA23_eof;
            this.min = DFA23_min;
            this.max = DFA23_max;
            this.accept = DFA23_accept;
            this.special = DFA23_special;
            this.transition = DFA23_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 197:22: ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*"; }
        }

    }

    const string DFA24_eotS =
        "\x27\uffff";
    const string DFA24_eofS =
        "\x27\uffff";
    const string DFA24_minS =
        "\x02\x0d\x10\uffff\x02\x00\x13\uffff";
    const string DFA24_maxS =
        "\x02\x44\x10\uffff\x02\x00\x13\uffff";
    const string DFA24_acceptS =
        "\x02\uffff\x01\x02\x21\uffff\x01\x01\x02\uffff";
    const string DFA24_specialS =
        "\x12\uffff\x01\x00\x01\x01\x13\uffff}>";
    static readonly string[] DFA24_transitionS = {
            "\x07\x02\x1d\uffff\x01\x01\x08\uffff\x03\x02\x02\uffff\x06"+
            "\x02",
            "\x01\x02\x01\x13\x05\x02\x1d\uffff\x01\x02\x01\uffff\x01\x24"+
            "\x01\x12\x02\x24\x03\uffff\x03\x02\x02\uffff\x06\x02",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA24_eot = DFA.UnpackEncodedString(DFA24_eotS);
    static readonly short[] DFA24_eof = DFA.UnpackEncodedString(DFA24_eofS);
    static readonly char[] DFA24_min = DFA.UnpackEncodedStringToUnsignedChars(DFA24_minS);
    static readonly char[] DFA24_max = DFA.UnpackEncodedStringToUnsignedChars(DFA24_maxS);
    static readonly short[] DFA24_accept = DFA.UnpackEncodedString(DFA24_acceptS);
    static readonly short[] DFA24_special = DFA.UnpackEncodedString(DFA24_specialS);
    static readonly short[][] DFA24_transition = DFA.UnpackEncodedStringArray(DFA24_transitionS);

    protected class DFA24 : DFA
    {
        public DFA24(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 24;
            this.eot = DFA24_eot;
            this.eof = DFA24_eof;
            this.min = DFA24_min;
            this.max = DFA24_max;
            this.accept = DFA24_accept;
            this.special = DFA24_special;
            this.transition = DFA24_transition;

        }

        override public string Description
        {
            get { return "200:1: cast_expression : ( '(' type_specifier ')' cast_expression | unary_expression );"; }
        }

    }


    protected internal int DFA24_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA24_18 = input.LA(1);

                   	 
                   	int index24_18 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred46_Gxc()) ) { s = 36; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index24_18);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA24_19 = input.LA(1);

                   	 
                   	int index24_19 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred46_Gxc()) ) { s = 36; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index24_19);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae24 =
            new NoViableAltException(dfa.Description, 24, _s, input);
        dfa.Error(nvae24);
        throw nvae24;
    }
    const string DFA25_eotS =
        "\x24\uffff";
    const string DFA25_eofS =
        "\x24\uffff";
    const string DFA25_minS =
        "\x01\x0d\x10\uffff\x01\x0d\x01\x00\x11\uffff";
    const string DFA25_maxS =
        "\x01\x44\x10\uffff\x01\x44\x01\x00\x11\uffff";
    const string DFA25_acceptS =
        "\x01\uffff\x01\x01\x07\uffff\x01\x02\x01\x03\x01\x04\x07\uffff"+
        "\x01\x05\x0f\uffff\x01\x06";
    const string DFA25_specialS =
        "\x12\uffff\x01\x00\x11\uffff}>";
    static readonly string[] DFA25_transitionS = {
            "\x07\x01\x1d\uffff\x01\x01\x08\uffff\x03\x0b\x02\uffff\x01"+
            "\x09\x01\x0a\x01\x11\x03\x0b",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x07\x13\x1d\uffff\x01\x12\x08\uffff\x03\x13\x02\uffff\x06"+
            "\x13",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA25_eot = DFA.UnpackEncodedString(DFA25_eotS);
    static readonly short[] DFA25_eof = DFA.UnpackEncodedString(DFA25_eofS);
    static readonly char[] DFA25_min = DFA.UnpackEncodedStringToUnsignedChars(DFA25_minS);
    static readonly char[] DFA25_max = DFA.UnpackEncodedStringToUnsignedChars(DFA25_maxS);
    static readonly short[] DFA25_accept = DFA.UnpackEncodedString(DFA25_acceptS);
    static readonly short[] DFA25_special = DFA.UnpackEncodedString(DFA25_specialS);
    static readonly short[][] DFA25_transition = DFA.UnpackEncodedStringArray(DFA25_transitionS);

    protected class DFA25 : DFA
    {
        public DFA25(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 25;
            this.eot = DFA25_eot;
            this.eof = DFA25_eof;
            this.min = DFA25_min;
            this.max = DFA25_max;
            this.accept = DFA25_accept;
            this.special = DFA25_special;
            this.transition = DFA25_transition;

        }

        override public string Description
        {
            get { return "205:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_specifier ')' );"; }
        }

    }


    protected internal int DFA25_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA25_18 = input.LA(1);

                   	 
                   	int index25_18 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred51_Gxc()) ) { s = 19; }

                   	else if ( (true) ) { s = 35; }

                   	 
                   	input.Seek(index25_18);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae25 =
            new NoViableAltException(dfa.Description, 25, _s, input);
        dfa.Error(nvae25);
        throw nvae25;
    }
    const string DFA27_eotS =
        "\u0133\uffff";
    const string DFA27_eofS =
        "\x01\uffff\x04\x0b\x01\uffff\x03\x0b\u012a\uffff";
    const string DFA27_minS =
        "\x01\x0d\x04\x2a\x01\x0d\x03\x2a\u00a0\uffff\x12\x00\x78\uffff";
    const string DFA27_maxS =
        "\x01\x31\x04\x5c\x01\x44\x03\x5c\u00a0\uffff\x12\x00\x78\uffff";
    const string DFA27_acceptS =
        "\x09\uffff\x01\x02\x01\x04\x01\x01\x23\uffff\x01\x05\x01\x03\u0102"+
        "\uffff";
    const string DFA27_specialS =
        "\u00a9\uffff\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01"+
        "\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01"+
        "\x0e\x01\x0f\x01\x10\x01\x11\x78\uffff}>";
    static readonly string[] DFA27_transitionS = {
            "\x01\x07\x01\x01\x01\x04\x01\x02\x01\x03\x01\x06\x01\x08\x1d"+
            "\uffff\x01\x05",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\u00b0\x01\u00aa\x01\u00ad\x01\u00ab\x01\u00ac\x01\u00af"+
            "\x01\u00b1\x1d\uffff\x01\u00ae\x02\uffff\x01\u00a9\x05\uffff"+
            "\x01\u00b6\x01\u00b7\x01\u00b5\x02\uffff\x01\u00b2\x01\u00b3"+
            "\x01\u00ba\x01\u00b4\x01\u00b8\x01\u00b9",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "\x01\x0b\x04\uffff\x02\x0b\x01\x2f\x01\x0b\x05\uffff\x01\x09"+
            "\x06\x0b\x01\x30\x01\x0a\x01\uffff\x01\x0b\x02\uffff\x18\x0b",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA27_eot = DFA.UnpackEncodedString(DFA27_eotS);
    static readonly short[] DFA27_eof = DFA.UnpackEncodedString(DFA27_eofS);
    static readonly char[] DFA27_min = DFA.UnpackEncodedStringToUnsignedChars(DFA27_minS);
    static readonly char[] DFA27_max = DFA.UnpackEncodedStringToUnsignedChars(DFA27_maxS);
    static readonly short[] DFA27_accept = DFA.UnpackEncodedString(DFA27_acceptS);
    static readonly short[] DFA27_special = DFA.UnpackEncodedString(DFA27_specialS);
    static readonly short[][] DFA27_transition = DFA.UnpackEncodedStringArray(DFA27_transitionS);

    protected class DFA27 : DFA
    {
        public DFA27(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;

        }

        override public string Description
        {
            get { return "214:1: postfix_expression : ( primary_expression -> ^( VARIABLE primary_expression ) | primary_expression '[' expression ']' | primary_expression '++' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_INCREMENT ) | primary_expression '--' -> ^( ASSIGNMENT ^( VARIABLE primary_expression ) UNARY_DECREMENT ) | primary_expression '(' ( argument_expression_list )? ')' -> ^( FUNCTION_CALL ^( primary_expression ( argument_expression_list )? ) ) );"; }
        }

    }


    protected internal int DFA27_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA27_169 = input.LA(1);

                   	 
                   	int index27_169 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_169);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA27_170 = input.LA(1);

                   	 
                   	int index27_170 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_170);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA27_171 = input.LA(1);

                   	 
                   	int index27_171 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_171);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA27_172 = input.LA(1);

                   	 
                   	int index27_172 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_172);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA27_173 = input.LA(1);

                   	 
                   	int index27_173 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_173);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA27_174 = input.LA(1);

                   	 
                   	int index27_174 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_174);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA27_175 = input.LA(1);

                   	 
                   	int index27_175 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_175);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA27_176 = input.LA(1);

                   	 
                   	int index27_176 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_176);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA27_177 = input.LA(1);

                   	 
                   	int index27_177 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_177);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA27_178 = input.LA(1);

                   	 
                   	int index27_178 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_178);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA27_179 = input.LA(1);

                   	 
                   	int index27_179 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_179);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 11 : 
                   	int LA27_180 = input.LA(1);

                   	 
                   	int index27_180 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_180);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 12 : 
                   	int LA27_181 = input.LA(1);

                   	 
                   	int index27_181 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_181);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 13 : 
                   	int LA27_182 = input.LA(1);

                   	 
                   	int index27_182 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_182);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 14 : 
                   	int LA27_183 = input.LA(1);

                   	 
                   	int index27_183 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_183);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 15 : 
                   	int LA27_184 = input.LA(1);

                   	 
                   	int index27_184 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_184);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 16 : 
                   	int LA27_185 = input.LA(1);

                   	 
                   	int index27_185 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_185);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 17 : 
                   	int LA27_186 = input.LA(1);

                   	 
                   	int index27_186 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred52_Gxc()) ) { s = 11; }

                   	else if ( (synpred53_Gxc()) ) { s = 9; }

                   	else if ( (synpred54_Gxc()) ) { s = 48; }

                   	else if ( (synpred55_Gxc()) ) { s = 10; }

                   	else if ( (true) ) { s = 47; }

                   	 
                   	input.Seek(index27_186);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae27 =
            new NoViableAltException(dfa.Description, 27, _s, input);
        dfa.Error(nvae27);
        throw nvae27;
    }
    const string DFA26_eotS =
        "\x13\uffff";
    const string DFA26_eofS =
        "\x13\uffff";
    const string DFA26_minS =
        "\x01\x0d\x12\uffff";
    const string DFA26_maxS =
        "\x01\x44\x12\uffff";
    const string DFA26_acceptS =
        "\x01\uffff\x01\x01\x10\uffff\x01\x02";
    const string DFA26_specialS =
        "\x13\uffff}>";
    static readonly string[] DFA26_transitionS = {
            "\x07\x01\x1d\uffff\x01\x01\x01\x12\x07\uffff\x03\x01\x02\uffff"+
            "\x06\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA26_eot = DFA.UnpackEncodedString(DFA26_eotS);
    static readonly short[] DFA26_eof = DFA.UnpackEncodedString(DFA26_eofS);
    static readonly char[] DFA26_min = DFA.UnpackEncodedStringToUnsignedChars(DFA26_minS);
    static readonly char[] DFA26_max = DFA.UnpackEncodedStringToUnsignedChars(DFA26_maxS);
    static readonly short[] DFA26_accept = DFA.UnpackEncodedString(DFA26_acceptS);
    static readonly short[] DFA26_special = DFA.UnpackEncodedString(DFA26_specialS);
    static readonly short[][] DFA26_transition = DFA.UnpackEncodedStringArray(DFA26_transitionS);

    protected class DFA26 : DFA
    {
        public DFA26(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 26;
            this.eot = DFA26_eot;
            this.eof = DFA26_eof;
            this.min = DFA26_min;
            this.max = DFA26_max;
            this.accept = DFA26_accept;
            this.special = DFA26_special;
            this.transition = DFA26_transition;

        }

        override public string Description
        {
            get { return "219:29: ( argument_expression_list )?"; }
        }

    }

    const string DFA29_eotS =
        "\x1b\uffff";
    const string DFA29_eofS =
        "\x1b\uffff";
    const string DFA29_minS =
        "\x01\x0d\x04\uffff\x01\x0d\x15\uffff";
    const string DFA29_maxS =
        "\x01\x31\x04\uffff\x01\x44\x15\uffff";
    const string DFA29_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x07\uffff\x01\x03\x10\uffff";
    const string DFA29_specialS =
        "\x1b\uffff}>";
    static readonly string[] DFA29_transitionS = {
            "\x01\x02\x01\x01\x05\x02\x1d\uffff\x01\x05",
            "",
            "",
            "",
            "",
            "\x07\x0a\x1d\uffff\x01\x0a\x02\uffff\x01\x02\x05\uffff\x03"+
            "\x0a\x02\uffff\x06\x0a",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA29_eot = DFA.UnpackEncodedString(DFA29_eotS);
    static readonly short[] DFA29_eof = DFA.UnpackEncodedString(DFA29_eofS);
    static readonly char[] DFA29_min = DFA.UnpackEncodedStringToUnsignedChars(DFA29_minS);
    static readonly char[] DFA29_max = DFA.UnpackEncodedStringToUnsignedChars(DFA29_maxS);
    static readonly short[] DFA29_accept = DFA.UnpackEncodedString(DFA29_acceptS);
    static readonly short[] DFA29_special = DFA.UnpackEncodedString(DFA29_specialS);
    static readonly short[][] DFA29_transition = DFA.UnpackEncodedStringArray(DFA29_transitionS);

    protected class DFA29 : DFA
    {
        public DFA29(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 29;
            this.eot = DFA29_eot;
            this.eof = DFA29_eof;
            this.min = DFA29_min;
            this.max = DFA29_max;
            this.accept = DFA29_accept;
            this.special = DFA29_special;
            this.transition = DFA29_transition;

        }

        override public string Description
        {
            get { return "231:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );"; }
        }

    }

    const string DFA32_eotS =
        "\x14\uffff";
    const string DFA32_eofS =
        "\x14\uffff";
    const string DFA32_minS =
        "\x01\x0d\x11\x00\x02\uffff";
    const string DFA32_maxS =
        "\x01\x44\x11\x00\x02\uffff";
    const string DFA32_acceptS =
        "\x12\uffff\x01\x01\x01\x02";
    const string DFA32_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01"+
        "\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01"+
        "\x0e\x01\x0f\x01\x10\x02\uffff}>";
    static readonly string[] DFA32_transitionS = {
            "\x01\x07\x01\x01\x01\x04\x01\x02\x01\x03\x01\x06\x01\x08\x1d"+
            "\uffff\x01\x05\x08\uffff\x01\x0d\x01\x0e\x01\x0c\x02\uffff\x01"+
            "\x09\x01\x0a\x01\x11\x01\x0b\x01\x0f\x01\x10",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            ""
    };

    static readonly short[] DFA32_eot = DFA.UnpackEncodedString(DFA32_eotS);
    static readonly short[] DFA32_eof = DFA.UnpackEncodedString(DFA32_eofS);
    static readonly char[] DFA32_min = DFA.UnpackEncodedStringToUnsignedChars(DFA32_minS);
    static readonly char[] DFA32_max = DFA.UnpackEncodedStringToUnsignedChars(DFA32_maxS);
    static readonly short[] DFA32_accept = DFA.UnpackEncodedString(DFA32_acceptS);
    static readonly short[] DFA32_special = DFA.UnpackEncodedString(DFA32_specialS);
    static readonly short[][] DFA32_transition = DFA.UnpackEncodedStringArray(DFA32_transitionS);

    protected class DFA32 : DFA
    {
        public DFA32(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 32;
            this.eot = DFA32_eot;
            this.eof = DFA32_eof;
            this.min = DFA32_min;
            this.max = DFA32_max;
            this.accept = DFA32_accept;
            this.special = DFA32_special;
            this.transition = DFA32_transition;

        }

        override public string Description
        {
            get { return "257:1: assignment_expression : ( lvalue assignment_operator assignment_expression -> ^( ASSIGNMENT lvalue assignment_expression ) | conditional_expression );"; }
        }

    }


    protected internal int DFA32_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA32_1 = input.LA(1);

                   	 
                   	int index32_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA32_2 = input.LA(1);

                   	 
                   	int index32_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA32_3 = input.LA(1);

                   	 
                   	int index32_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA32_4 = input.LA(1);

                   	 
                   	int index32_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA32_5 = input.LA(1);

                   	 
                   	int index32_5 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_5);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA32_6 = input.LA(1);

                   	 
                   	int index32_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_6);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA32_7 = input.LA(1);

                   	 
                   	int index32_7 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_7);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA32_8 = input.LA(1);

                   	 
                   	int index32_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA32_9 = input.LA(1);

                   	 
                   	int index32_9 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_9);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA32_10 = input.LA(1);

                   	 
                   	int index32_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA32_11 = input.LA(1);

                   	 
                   	int index32_11 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_11);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 11 : 
                   	int LA32_12 = input.LA(1);

                   	 
                   	int index32_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 12 : 
                   	int LA32_13 = input.LA(1);

                   	 
                   	int index32_13 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_13);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 13 : 
                   	int LA32_14 = input.LA(1);

                   	 
                   	int index32_14 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_14);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 14 : 
                   	int LA32_15 = input.LA(1);

                   	 
                   	int index32_15 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_15);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 15 : 
                   	int LA32_16 = input.LA(1);

                   	 
                   	int index32_16 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_16);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 16 : 
                   	int LA32_17 = input.LA(1);

                   	 
                   	int index32_17 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred71_Gxc()) ) { s = 18; }

                   	else if ( (true) ) { s = 19; }

                   	 
                   	input.Seek(index32_17);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae32 =
            new NoViableAltException(dfa.Description, 32, _s, input);
        dfa.Error(nvae32);
        throw nvae32;
    }
    const string DFA33_eotS =
        "\x0c\uffff";
    const string DFA33_eofS =
        "\x0c\uffff";
    const string DFA33_minS =
        "\x01\x2a\x0b\uffff";
    const string DFA33_maxS =
        "\x01\x4e\x0b\uffff";
    const string DFA33_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01"+
        "\x07\x01\x08\x01\x09\x01\x0a\x01\x0b";
    const string DFA33_specialS =
        "\x0c\uffff}>";
    static readonly string[] DFA33_transitionS = {
            "\x01\x01\x1a\uffff\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06"+
            "\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA33_eot = DFA.UnpackEncodedString(DFA33_eotS);
    static readonly short[] DFA33_eof = DFA.UnpackEncodedString(DFA33_eofS);
    static readonly char[] DFA33_min = DFA.UnpackEncodedStringToUnsignedChars(DFA33_minS);
    static readonly char[] DFA33_max = DFA.UnpackEncodedStringToUnsignedChars(DFA33_maxS);
    static readonly short[] DFA33_accept = DFA.UnpackEncodedString(DFA33_acceptS);
    static readonly short[] DFA33_special = DFA.UnpackEncodedString(DFA33_specialS);
    static readonly short[][] DFA33_transition = DFA.UnpackEncodedStringArray(DFA33_transitionS);

    protected class DFA33 : DFA
    {
        public DFA33(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 33;
            this.eot = DFA33_eot;
            this.eof = DFA33_eof;
            this.min = DFA33_min;
            this.max = DFA33_max;
            this.accept = DFA33_accept;
            this.special = DFA33_special;
            this.transition = DFA33_transition;

        }

        override public string Description
        {
            get { return "266:1: assignment_operator : ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' );"; }
        }

    }

    const string DFA36_eotS =
        "\x0a\uffff";
    const string DFA36_eofS =
        "\x01\x01\x09\uffff";
    const string DFA36_minS =
        "\x01\x2f\x09\uffff";
    const string DFA36_maxS =
        "\x01\x52\x09\uffff";
    const string DFA36_acceptS =
        "\x01\uffff\x01\x02\x07\uffff\x01\x01";
    const string DFA36_specialS =
        "\x0a\uffff}>";
    static readonly string[] DFA36_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x15\uffff\x03"+
            "\x01\x01\x09",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA36_eot = DFA.UnpackEncodedString(DFA36_eotS);
    static readonly short[] DFA36_eof = DFA.UnpackEncodedString(DFA36_eofS);
    static readonly char[] DFA36_min = DFA.UnpackEncodedStringToUnsignedChars(DFA36_minS);
    static readonly char[] DFA36_max = DFA.UnpackEncodedStringToUnsignedChars(DFA36_maxS);
    static readonly short[] DFA36_accept = DFA.UnpackEncodedString(DFA36_acceptS);
    static readonly short[] DFA36_special = DFA.UnpackEncodedString(DFA36_specialS);
    static readonly short[][] DFA36_transition = DFA.UnpackEncodedStringArray(DFA36_transitionS);

    protected class DFA36 : DFA
    {
        public DFA36(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 36;
            this.eot = DFA36_eot;
            this.eof = DFA36_eof;
            this.min = DFA36_min;
            this.max = DFA36_max;
            this.accept = DFA36_accept;
            this.special = DFA36_special;
            this.transition = DFA36_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 289:28: ( '&&' inclusive_or_expression )*"; }
        }

    }

    const string DFA37_eotS =
        "\x0b\uffff";
    const string DFA37_eofS =
        "\x01\x01\x0a\uffff";
    const string DFA37_minS =
        "\x01\x2f\x0a\uffff";
    const string DFA37_maxS =
        "\x01\x53\x0a\uffff";
    const string DFA37_acceptS =
        "\x01\uffff\x01\x02\x08\uffff\x01\x01";
    const string DFA37_specialS =
        "\x0b\uffff}>";
    static readonly string[] DFA37_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x15\uffff\x04"+
            "\x01\x01\x0a",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA37_eot = DFA.UnpackEncodedString(DFA37_eotS);
    static readonly short[] DFA37_eof = DFA.UnpackEncodedString(DFA37_eofS);
    static readonly char[] DFA37_min = DFA.UnpackEncodedStringToUnsignedChars(DFA37_minS);
    static readonly char[] DFA37_max = DFA.UnpackEncodedStringToUnsignedChars(DFA37_maxS);
    static readonly short[] DFA37_accept = DFA.UnpackEncodedString(DFA37_acceptS);
    static readonly short[] DFA37_special = DFA.UnpackEncodedString(DFA37_specialS);
    static readonly short[][] DFA37_transition = DFA.UnpackEncodedStringArray(DFA37_transitionS);

    protected class DFA37 : DFA
    {
        public DFA37(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 37;
            this.eot = DFA37_eot;
            this.eof = DFA37_eof;
            this.min = DFA37_min;
            this.max = DFA37_max;
            this.accept = DFA37_accept;
            this.special = DFA37_special;
            this.transition = DFA37_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 293:28: ( '|' exclusive_or_expression )*"; }
        }

    }

    const string DFA38_eotS =
        "\x0c\uffff";
    const string DFA38_eofS =
        "\x01\x01\x0b\uffff";
    const string DFA38_minS =
        "\x01\x2f\x0b\uffff";
    const string DFA38_maxS =
        "\x01\x54\x0b\uffff";
    const string DFA38_acceptS =
        "\x01\uffff\x01\x02\x09\uffff\x01\x01";
    const string DFA38_specialS =
        "\x0c\uffff}>";
    static readonly string[] DFA38_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x15\uffff\x05"+
            "\x01\x01\x0b",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA38_eot = DFA.UnpackEncodedString(DFA38_eotS);
    static readonly short[] DFA38_eof = DFA.UnpackEncodedString(DFA38_eofS);
    static readonly char[] DFA38_min = DFA.UnpackEncodedStringToUnsignedChars(DFA38_minS);
    static readonly char[] DFA38_max = DFA.UnpackEncodedStringToUnsignedChars(DFA38_maxS);
    static readonly short[] DFA38_accept = DFA.UnpackEncodedString(DFA38_acceptS);
    static readonly short[] DFA38_special = DFA.UnpackEncodedString(DFA38_specialS);
    static readonly short[][] DFA38_transition = DFA.UnpackEncodedStringArray(DFA38_transitionS);

    protected class DFA38 : DFA
    {
        public DFA38(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 38;
            this.eot = DFA38_eot;
            this.eof = DFA38_eof;
            this.min = DFA38_min;
            this.max = DFA38_max;
            this.accept = DFA38_accept;
            this.special = DFA38_special;
            this.transition = DFA38_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 297:19: ( '^' and_expression )*"; }
        }

    }

    const string DFA39_eotS =
        "\x0d\uffff";
    const string DFA39_eofS =
        "\x01\x01\x0c\uffff";
    const string DFA39_minS =
        "\x01\x2f\x0c\uffff";
    const string DFA39_maxS =
        "\x01\x54\x0c\uffff";
    const string DFA39_acceptS =
        "\x01\uffff\x01\x02\x0a\uffff\x01\x01";
    const string DFA39_specialS =
        "\x0d\uffff}>";
    static readonly string[] DFA39_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x08\uffff\x01"+
            "\x0c\x0c\uffff\x06\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA39_eot = DFA.UnpackEncodedString(DFA39_eotS);
    static readonly short[] DFA39_eof = DFA.UnpackEncodedString(DFA39_eofS);
    static readonly char[] DFA39_min = DFA.UnpackEncodedStringToUnsignedChars(DFA39_minS);
    static readonly char[] DFA39_max = DFA.UnpackEncodedStringToUnsignedChars(DFA39_maxS);
    static readonly short[] DFA39_accept = DFA.UnpackEncodedString(DFA39_acceptS);
    static readonly short[] DFA39_special = DFA.UnpackEncodedString(DFA39_specialS);
    static readonly short[][] DFA39_transition = DFA.UnpackEncodedStringArray(DFA39_transitionS);

    protected class DFA39 : DFA
    {
        public DFA39(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 39;
            this.eot = DFA39_eot;
            this.eof = DFA39_eof;
            this.min = DFA39_min;
            this.max = DFA39_max;
            this.accept = DFA39_accept;
            this.special = DFA39_special;
            this.transition = DFA39_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 301:24: ( '&' equality_expression )*"; }
        }

    }

    const string DFA41_eotS =
        "\x0f\uffff";
    const string DFA41_eofS =
        "\x01\x01\x0e\uffff";
    const string DFA41_minS =
        "\x01\x2f\x0e\uffff";
    const string DFA41_maxS =
        "\x01\x56\x0e\uffff";
    const string DFA41_acceptS =
        "\x01\uffff\x01\x02\x0b\uffff\x01\x01\x01\uffff";
    const string DFA41_specialS =
        "\x0f\uffff}>";
    static readonly string[] DFA41_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x08\uffff\x01"+
            "\x01\x0c\uffff\x06\x01\x02\x0d",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA41_eot = DFA.UnpackEncodedString(DFA41_eotS);
    static readonly short[] DFA41_eof = DFA.UnpackEncodedString(DFA41_eofS);
    static readonly char[] DFA41_min = DFA.UnpackEncodedStringToUnsignedChars(DFA41_minS);
    static readonly char[] DFA41_max = DFA.UnpackEncodedStringToUnsignedChars(DFA41_maxS);
    static readonly short[] DFA41_accept = DFA.UnpackEncodedString(DFA41_acceptS);
    static readonly short[] DFA41_special = DFA.UnpackEncodedString(DFA41_specialS);
    static readonly short[][] DFA41_transition = DFA.UnpackEncodedStringArray(DFA41_transitionS);

    protected class DFA41 : DFA
    {
        public DFA41(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 41;
            this.eot = DFA41_eot;
            this.eof = DFA41_eof;
            this.min = DFA41_min;
            this.max = DFA41_max;
            this.accept = DFA41_accept;
            this.special = DFA41_special;
            this.transition = DFA41_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 304:26: ( ( '==' | '!=' ) relational_expression )*"; }
        }

    }

    const string DFA43_eotS =
        "\x13\uffff";
    const string DFA43_eofS =
        "\x01\x01\x12\uffff";
    const string DFA43_minS =
        "\x01\x2f\x12\uffff";
    const string DFA43_maxS =
        "\x01\x5a\x12\uffff";
    const string DFA43_acceptS =
        "\x01\uffff\x01\x02\x0d\uffff\x01\x01\x03\uffff";
    const string DFA43_specialS =
        "\x13\uffff}>";
    static readonly string[] DFA43_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x08\uffff\x01"+
            "\x01\x0c\uffff\x08\x01\x04\x0f",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA43_eot = DFA.UnpackEncodedString(DFA43_eotS);
    static readonly short[] DFA43_eof = DFA.UnpackEncodedString(DFA43_eofS);
    static readonly char[] DFA43_min = DFA.UnpackEncodedStringToUnsignedChars(DFA43_minS);
    static readonly char[] DFA43_max = DFA.UnpackEncodedStringToUnsignedChars(DFA43_maxS);
    static readonly short[] DFA43_accept = DFA.UnpackEncodedString(DFA43_acceptS);
    static readonly short[] DFA43_special = DFA.UnpackEncodedString(DFA43_specialS);
    static readonly short[][] DFA43_transition = DFA.UnpackEncodedStringArray(DFA43_transitionS);

    protected class DFA43 : DFA
    {
        public DFA43(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 43;
            this.eot = DFA43_eot;
            this.eof = DFA43_eof;
            this.min = DFA43_min;
            this.max = DFA43_max;
            this.accept = DFA43_accept;
            this.special = DFA43_special;
            this.transition = DFA43_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 308:21: ( ( '<' | '>' | '<=' | '>=' ) shift_expression )*"; }
        }

    }

    const string DFA45_eotS =
        "\x15\uffff";
    const string DFA45_eofS =
        "\x01\x01\x14\uffff";
    const string DFA45_minS =
        "\x01\x2f\x14\uffff";
    const string DFA45_maxS =
        "\x01\x5c\x14\uffff";
    const string DFA45_acceptS =
        "\x01\uffff\x01\x02\x11\uffff\x01\x01\x01\uffff";
    const string DFA45_specialS =
        "\x15\uffff}>";
    static readonly string[] DFA45_transitionS = {
            "\x02\x01\x01\uffff\x01\x01\x06\uffff\x01\x01\x08\uffff\x01"+
            "\x01\x0c\uffff\x0c\x01\x02\x13",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA45_eot = DFA.UnpackEncodedString(DFA45_eotS);
    static readonly short[] DFA45_eof = DFA.UnpackEncodedString(DFA45_eofS);
    static readonly char[] DFA45_min = DFA.UnpackEncodedStringToUnsignedChars(DFA45_minS);
    static readonly char[] DFA45_max = DFA.UnpackEncodedStringToUnsignedChars(DFA45_maxS);
    static readonly short[] DFA45_accept = DFA.UnpackEncodedString(DFA45_acceptS);
    static readonly short[] DFA45_special = DFA.UnpackEncodedString(DFA45_specialS);
    static readonly short[][] DFA45_transition = DFA.UnpackEncodedStringArray(DFA45_transitionS);

    protected class DFA45 : DFA
    {
        public DFA45(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 45;
            this.eot = DFA45_eot;
            this.eof = DFA45_eof;
            this.min = DFA45_min;
            this.max = DFA45_max;
            this.accept = DFA45_accept;
            this.special = DFA45_special;
            this.transition = DFA45_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 312:24: ( ( '<<' | '>>' ) additive_expression )*"; }
        }

    }

    const string DFA46_eotS =
        "\x45\uffff";
    const string DFA46_eofS =
        "\x45\uffff";
    const string DFA46_minS =
        "\x01\x0d\x01\x2a\x43\uffff";
    const string DFA46_maxS =
        "\x01\x61\x01\x5c\x43\uffff";
    const string DFA46_acceptS =
        "\x02\uffff\x01\x01\x01\uffff\x01\x02\x01\x03\x10\uffff\x01\x04"+
        "\x01\uffff\x01\x05\x02\uffff\x01\x06\x02\uffff\x01\x07\x26\uffff";
    const string DFA46_specialS =
        "\x45\uffff}>";
    static readonly string[] DFA46_transitionS = {
            "\x01\x05\x01\x01\x05\x05\x01\x16\x01\uffff\x01\x16\x03\x18"+
            "\x02\x1b\x02\x1e\x12\uffff\x02\x05\x08\uffff\x03\x05\x02\uffff"+
            "\x06\x05\x18\uffff\x02\x02\x01\x04\x01\uffff\x01\x1b",
            "\x01\x05\x04\uffff\x03\x05\x06\uffff\x01\x05\x01\uffff\x07"+
            "\x05\x01\uffff\x01\x05\x02\uffff\x0b\x05\x01\x02\x0c\x05",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA46_eot = DFA.UnpackEncodedString(DFA46_eotS);
    static readonly short[] DFA46_eof = DFA.UnpackEncodedString(DFA46_eofS);
    static readonly char[] DFA46_min = DFA.UnpackEncodedStringToUnsignedChars(DFA46_minS);
    static readonly char[] DFA46_max = DFA.UnpackEncodedStringToUnsignedChars(DFA46_maxS);
    static readonly short[] DFA46_accept = DFA.UnpackEncodedString(DFA46_acceptS);
    static readonly short[] DFA46_special = DFA.UnpackEncodedString(DFA46_specialS);
    static readonly short[][] DFA46_transition = DFA.UnpackEncodedStringArray(DFA46_transitionS);

    protected class DFA46 : DFA
    {
        public DFA46(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 46;
            this.eot = DFA46_eot;
            this.eof = DFA46_eof;
            this.min = DFA46_min;
            this.max = DFA46_max;
            this.accept = DFA46_accept;
            this.special = DFA46_special;
            this.transition = DFA46_transition;

        }

        override public string Description
        {
            get { return "317:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement | comment_statement );"; }
        }

    }

    const string DFA48_eotS =
        "\x4d\uffff";
    const string DFA48_eofS =
        "\x4d\uffff";
    const string DFA48_minS =
        "\x01\x0d\x01\x0e\x4b\uffff";
    const string DFA48_maxS =
        "\x01\x61\x01\x5c\x4b\uffff";
    const string DFA48_acceptS =
        "\x02\uffff\x01\x02\x1e\uffff\x01\x01\x2b\uffff";
    const string DFA48_specialS =
        "\x4d\uffff}>";
    static readonly string[] DFA48_transitionS = {
            "\x01\x02\x01\x01\x06\x02\x01\uffff\x08\x02\x10\uffff\x01\x21"+
            "\x01\uffff\x02\x02\x01\uffff\x04\x21\x01\uffff\x01\x21\x01\uffff"+
            "\x03\x02\x02\uffff\x06\x02\x18\uffff\x05\x02",
            "\x01\x21\x1b\uffff\x01\x02\x04\uffff\x03\x02\x06\uffff\x01"+
            "\x02\x01\uffff\x07\x02\x01\uffff\x01\x02\x02\uffff\x18\x02",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA48_eot = DFA.UnpackEncodedString(DFA48_eotS);
    static readonly short[] DFA48_eof = DFA.UnpackEncodedString(DFA48_eofS);
    static readonly char[] DFA48_min = DFA.UnpackEncodedStringToUnsignedChars(DFA48_minS);
    static readonly char[] DFA48_max = DFA.UnpackEncodedStringToUnsignedChars(DFA48_maxS);
    static readonly short[] DFA48_accept = DFA.UnpackEncodedString(DFA48_acceptS);
    static readonly short[] DFA48_special = DFA.UnpackEncodedString(DFA48_specialS);
    static readonly short[][] DFA48_transition = DFA.UnpackEncodedStringArray(DFA48_transitionS);

    protected class DFA48 : DFA
    {
        public DFA48(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 48;
            this.eot = DFA48_eot;
            this.eof = DFA48_eof;
            this.min = DFA48_min;
            this.max = DFA48_max;
            this.accept = DFA48_accept;
            this.special = DFA48_special;
            this.transition = DFA48_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 339:9: ( declaration )*"; }
        }

    }

    const string DFA49_eotS =
        "\x21\uffff";
    const string DFA49_eofS =
        "\x21\uffff";
    const string DFA49_minS =
        "\x01\x0d\x20\uffff";
    const string DFA49_maxS =
        "\x01\x61\x20\uffff";
    const string DFA49_acceptS =
        "\x01\uffff\x01\x01\x1e\uffff\x01\x02";
    const string DFA49_specialS =
        "\x21\uffff}>";
    static readonly string[] DFA49_transitionS = {
            "\x08\x01\x01\uffff\x08\x01\x12\uffff\x02\x01\x08\uffff\x03"+
            "\x01\x02\uffff\x06\x01\x18\uffff\x03\x01\x01\x20\x01\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA49_eot = DFA.UnpackEncodedString(DFA49_eotS);
    static readonly short[] DFA49_eof = DFA.UnpackEncodedString(DFA49_eofS);
    static readonly char[] DFA49_min = DFA.UnpackEncodedStringToUnsignedChars(DFA49_minS);
    static readonly char[] DFA49_max = DFA.UnpackEncodedStringToUnsignedChars(DFA49_maxS);
    static readonly short[] DFA49_accept = DFA.UnpackEncodedString(DFA49_acceptS);
    static readonly short[] DFA49_special = DFA.UnpackEncodedString(DFA49_specialS);
    static readonly short[][] DFA49_transition = DFA.UnpackEncodedStringArray(DFA49_transitionS);

    protected class DFA49 : DFA
    {
        public DFA49(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 49;
            this.eot = DFA49_eot;
            this.eof = DFA49_eof;
            this.min = DFA49_min;
            this.max = DFA49_max;
            this.accept = DFA49_accept;
            this.special = DFA49_special;
            this.transition = DFA49_transition;

        }

        override public string Description
        {
            get { return "339:22: ( statement_list )?"; }
        }

    }

    const string DFA50_eotS =
        "\x22\uffff";
    const string DFA50_eofS =
        "\x01\x01\x21\uffff";
    const string DFA50_minS =
        "\x01\x0d\x21\uffff";
    const string DFA50_maxS =
        "\x01\x61\x21\uffff";
    const string DFA50_acceptS =
        "\x01\uffff\x01\x02\x01\uffff\x01\x01\x1e\uffff";
    const string DFA50_specialS =
        "\x22\uffff}>";
    static readonly string[] DFA50_transitionS = {
            "\x08\x03\x01\uffff\x08\x03\x12\uffff\x02\x03\x08\uffff\x03"+
            "\x03\x02\uffff\x06\x03\x18\uffff\x03\x03\x01\x01\x01\x03",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA50_eot = DFA.UnpackEncodedString(DFA50_eotS);
    static readonly short[] DFA50_eof = DFA.UnpackEncodedString(DFA50_eofS);
    static readonly char[] DFA50_min = DFA.UnpackEncodedStringToUnsignedChars(DFA50_minS);
    static readonly char[] DFA50_max = DFA.UnpackEncodedStringToUnsignedChars(DFA50_maxS);
    static readonly short[] DFA50_accept = DFA.UnpackEncodedString(DFA50_acceptS);
    static readonly short[] DFA50_special = DFA.UnpackEncodedString(DFA50_specialS);
    static readonly short[][] DFA50_transition = DFA.UnpackEncodedStringArray(DFA50_transitionS);

    protected class DFA50 : DFA
    {
        public DFA50(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 50;
            this.eot = DFA50_eot;
            this.eof = DFA50_eof;
            this.min = DFA50_min;
            this.max = DFA50_max;
            this.accept = DFA50_accept;
            this.special = DFA50_special;
            this.transition = DFA50_transition;

        }

        override public string Description
        {
            get { return "()+ loopback of 343:4: ( statement )+"; }
        }

    }

    const string DFA51_eotS =
        "\x13\uffff";
    const string DFA51_eofS =
        "\x13\uffff";
    const string DFA51_minS =
        "\x01\x0d\x12\uffff";
    const string DFA51_maxS =
        "\x01\x44\x12\uffff";
    const string DFA51_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x10\uffff";
    const string DFA51_specialS =
        "\x13\uffff}>";
    static readonly string[] DFA51_transitionS = {
            "\x07\x02\x1c\uffff\x01\x01\x01\x02\x08\uffff\x03\x02\x02\uffff"+
            "\x06\x02",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA51_eot = DFA.UnpackEncodedString(DFA51_eotS);
    static readonly short[] DFA51_eof = DFA.UnpackEncodedString(DFA51_eofS);
    static readonly char[] DFA51_min = DFA.UnpackEncodedStringToUnsignedChars(DFA51_minS);
    static readonly char[] DFA51_max = DFA.UnpackEncodedStringToUnsignedChars(DFA51_maxS);
    static readonly short[] DFA51_accept = DFA.UnpackEncodedString(DFA51_acceptS);
    static readonly short[] DFA51_special = DFA.UnpackEncodedString(DFA51_specialS);
    static readonly short[][] DFA51_transition = DFA.UnpackEncodedStringArray(DFA51_transitionS);

    protected class DFA51 : DFA
    {
        public DFA51(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 51;
            this.eot = DFA51_eot;
            this.eof = DFA51_eof;
            this.min = DFA51_min;
            this.max = DFA51_max;
            this.accept = DFA51_accept;
            this.special = DFA51_special;
            this.transition = DFA51_transition;

        }

        override public string Description
        {
            get { return "346:1: expression_statement : ( ';' | expression ';' );"; }
        }

    }

    const string DFA54_eotS =
        "\x13\uffff";
    const string DFA54_eofS =
        "\x13\uffff";
    const string DFA54_minS =
        "\x01\x0d\x12\uffff";
    const string DFA54_maxS =
        "\x01\x44\x12\uffff";
    const string DFA54_acceptS =
        "\x01\uffff\x01\x01\x10\uffff\x01\x02";
    const string DFA54_specialS =
        "\x13\uffff}>";
    static readonly string[] DFA54_transitionS = {
            "\x07\x01\x1d\uffff\x01\x01\x01\x12\x07\uffff\x03\x01\x02\uffff"+
            "\x06\x01",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA54_eot = DFA.UnpackEncodedString(DFA54_eotS);
    static readonly short[] DFA54_eof = DFA.UnpackEncodedString(DFA54_eofS);
    static readonly char[] DFA54_min = DFA.UnpackEncodedStringToUnsignedChars(DFA54_minS);
    static readonly char[] DFA54_max = DFA.UnpackEncodedStringToUnsignedChars(DFA54_maxS);
    static readonly short[] DFA54_accept = DFA.UnpackEncodedString(DFA54_acceptS);
    static readonly short[] DFA54_special = DFA.UnpackEncodedString(DFA54_specialS);
    static readonly short[][] DFA54_transition = DFA.UnpackEncodedStringArray(DFA54_transitionS);

    protected class DFA54 : DFA
    {
        public DFA54(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 54;
            this.eot = DFA54_eot;
            this.eof = DFA54_eof;
            this.min = DFA54_min;
            this.max = DFA54_max;
            this.accept = DFA54_accept;
            this.special = DFA54_special;
            this.transition = DFA54_transition;

        }

        override public string Description
        {
            get { return "361:101: (inc= expression )?"; }
        }

    }

 

    public static readonly BitSet FOLLOW_gx_meta_declarations_in_translation_unit191 = new BitSet(new ulong[]{0x01785A0000004000UL,0x0000000080000000UL});
    public static readonly BitSet FOLLOW_declaration_in_translation_unit194 = new BitSet(new ulong[]{0x0178400000004000UL,0x0000000080000000UL});
    public static readonly BitSet FOLLOW_compound_statement_in_translation_unit197 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_gx_meta_data_in_gx_meta_declarations212 = new BitSet(new ulong[]{0x0000200000000002UL});
    public static readonly BitSet FOLLOW_gx_resource_in_gx_meta_declarations215 = new BitSet(new ulong[]{0x0000200000000002UL});
    public static readonly BitSet FOLLOW_41_in_gx_meta_data232 = new BitSet(new ulong[]{0x0000040000000000UL});
    public static readonly BitSet FOLLOW_42_in_gx_meta_data234 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_gx_meta_data236 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_43_in_gx_meta_data246 = new BitSet(new ulong[]{0x0000040000000000UL});
    public static readonly BitSet FOLLOW_42_in_gx_meta_data248 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_gx_meta_data250 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_44_in_gx_meta_data259 = new BitSet(new ulong[]{0x0000040000000000UL});
    public static readonly BitSet FOLLOW_42_in_gx_meta_data261 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_gx_meta_data263 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_45_in_gx_resource283 = new BitSet(new ulong[]{0x0000040000000000UL});
    public static readonly BitSet FOLLOW_42_in_gx_resource285 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_gx_resource287 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_declaration_in_declaration304 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_function_declaration_in_declaration310 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_declaration_in_declaration315 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_46_in_type_declaration337 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_type_declaration339 = new BitSet(new ulong[]{0x0001800000000000UL});
    public static readonly BitSet FOLLOW_47_in_type_declaration342 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_type_declaration344 = new BitSet(new ulong[]{0x0001800000000000UL});
    public static readonly BitSet FOLLOW_48_in_type_declaration348 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_dll_specifier_in_function_declaration372 = new BitSet(new ulong[]{0x0178000000004000UL});
    public static readonly BitSet FOLLOW_returntype_specifier_in_function_declaration375 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_function_declaration377 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_function_declaration379 = new BitSet(new ulong[]{0x01FC000000004000UL});
    public static readonly BitSet FOLLOW_func_declaration_arugments_in_function_declaration381 = new BitSet(new ulong[]{0x01FC000000004000UL});
    public static readonly BitSet FOLLOW_50_in_function_declaration384 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_function_declaration386 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_specifier_in_variable_declaration423 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_identifier_list_in_variable_declaration425 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_variable_declaration427 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_51_in_returntype_specifier445 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_52_in_returntype_specifier452 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_53_in_returntype_specifier460 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_54_in_returntype_specifier467 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_id_in_returntype_specifier474 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_51_in_func_declaration_specifiers493 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_52_in_func_declaration_specifiers500 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_53_in_func_declaration_specifiers508 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_54_in_func_declaration_specifiers515 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_id_in_func_declaration_specifiers522 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_55_in_func_declaration_specifiers544 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_51_in_func_declaration_specifiers546 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_55_in_func_declaration_specifiers553 = new BitSet(new ulong[]{0x0010000000000000UL});
    public static readonly BitSet FOLLOW_52_in_func_declaration_specifiers555 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_55_in_func_declaration_specifiers563 = new BitSet(new ulong[]{0x0020000000000000UL});
    public static readonly BitSet FOLLOW_53_in_func_declaration_specifiers565 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_55_in_func_declaration_specifiers572 = new BitSet(new ulong[]{0x0040000000000000UL});
    public static readonly BitSet FOLLOW_54_in_func_declaration_specifiers574 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_55_in_func_declaration_specifiers581 = new BitSet(new ulong[]{0x0178000000004000UL});
    public static readonly BitSet FOLLOW_type_id_in_func_declaration_specifiers583 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_56_in_dll_specifier598 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_dll_specifier600 = new BitSet(new ulong[]{0x0200000000000000UL});
    public static readonly BitSet FOLLOW_57_in_dll_specifier602 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_func_declaration_specifiers_in_func_declaration_arugments618 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_47_in_func_declaration_arugments621 = new BitSet(new ulong[]{0x01F8000000004000UL});
    public static readonly BitSet FOLLOW_func_declaration_specifiers_in_func_declaration_arugments623 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_51_in_variable_type_specifier637 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_52_in_variable_type_specifier644 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_variable_type_specifier650 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier653 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_variable_type_specifier656 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_53_in_variable_type_specifier667 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_variable_type_specifier672 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier675 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_variable_type_specifier678 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_54_in_variable_type_specifier690 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_variable_type_specifier696 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_variable_type_specifier699 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_variable_type_specifier703 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_type_id_in_variable_type_specifier715 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_51_in_type_specifier730 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_52_in_type_specifier736 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_type_specifier742 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_type_specifier745 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_type_specifier746 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_53_in_type_specifier756 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_type_specifier761 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_type_specifier764 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_type_specifier766 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_54_in_type_specifier777 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_49_in_type_specifier783 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_type_specifier786 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_type_specifier788 = new BitSet(new ulong[]{0x0002000000000002UL});
    public static readonly BitSet FOLLOW_type_id_in_type_specifier799 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_type_id820 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_identifier_list837 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_47_in_identifier_list841 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_identifier_in_identifier_list844 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_identifier862 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignment_expression_in_argument_expression_list887 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_47_in_argument_expression_list890 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_assignment_expression_in_argument_expression_list893 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_multiplicative_expression_in_additive_expression907 = new BitSet(new ulong[]{0x0C00000000000002UL});
    public static readonly BitSet FOLLOW_58_in_additive_expression911 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_multiplicative_expression_in_additive_expression914 = new BitSet(new ulong[]{0x0C00000000000002UL});
    public static readonly BitSet FOLLOW_59_in_additive_expression918 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_multiplicative_expression_in_additive_expression921 = new BitSet(new ulong[]{0x0C00000000000002UL});
    public static readonly BitSet FOLLOW_cast_expression_in_multiplicative_expression935 = new BitSet(new ulong[]{0x7000000000000002UL});
    public static readonly BitSet FOLLOW_60_in_multiplicative_expression939 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_multiplicative_expression942 = new BitSet(new ulong[]{0x7000000000000002UL});
    public static readonly BitSet FOLLOW_61_in_multiplicative_expression946 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_multiplicative_expression949 = new BitSet(new ulong[]{0x7000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_multiplicative_expression953 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_multiplicative_expression956 = new BitSet(new ulong[]{0x7000000000000002UL});
    public static readonly BitSet FOLLOW_49_in_cast_expression969 = new BitSet(new ulong[]{0x0178400000004000UL});
    public static readonly BitSet FOLLOW_type_specifier_in_cast_expression972 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_cast_expression974 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_cast_expression977 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_expression_in_cast_expression982 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_postfix_expression_in_unary_expression993 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_63_in_unary_expression998 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression1001 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_64_in_unary_expression1006 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression1009 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_in_unary_expression1014 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_unary_expression1016 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_unary_expression1021 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression1023 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_unary_expression1028 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_unary_expression1030 = new BitSet(new ulong[]{0x0178400000004000UL});
    public static readonly BitSet FOLLOW_type_specifier_in_unary_expression1033 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_unary_expression1035 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_postfix_expression1047 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_postfix_expression1060 = new BitSet(new ulong[]{0x0100000000000000UL});
    public static readonly BitSet FOLLOW_56_in_postfix_expression1062 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_postfix_expression1064 = new BitSet(new ulong[]{0x0200000000000000UL});
    public static readonly BitSet FOLLOW_57_in_postfix_expression1066 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_postfix_expression1073 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_postfix_expression1075 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_postfix_expression1095 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_64_in_postfix_expression1097 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_postfix_expression1120 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_postfix_expression1122 = new BitSet(new ulong[]{0x9C060000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_argument_expression_list_in_postfix_expression1124 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_postfix_expression1127 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_66_in_unary_operator1150 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_60_in_unary_operator1156 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_58_in_unary_operator1162 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_59_in_unary_operator1168 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_67_in_unary_operator1174 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_68_in_unary_operator1180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_primary_expression1192 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constant_in_primary_expression1197 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_49_in_primary_expression1202 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_primary_expression1205 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_primary_expression1207 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HEX_LITERAL_in_constant1224 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OCTAL_LITERAL_in_constant1234 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_constant1244 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_49_in_constant1252 = new BitSet(new ulong[]{0x0010000000000000UL});
    public static readonly BitSet FOLLOW_52_in_constant1254 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_constant1256 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_DECIMAL_LITERAL_in_constant1259 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CHARACTER_LITERAL_in_constant1268 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STRING_LITERAL_in_constant1276 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FLOATING_POINT_LITERAL_in_constant1286 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignment_expression_in_expression1302 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_47_in_expression1305 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_assignment_expression_in_expression1309 = new BitSet(new ulong[]{0x0000800000000002UL});
    public static readonly BitSet FOLLOW_conditional_expression_in_constant_expression1322 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_assignment_expression1333 = new BitSet(new ulong[]{0x0000040000000000UL,0x0000000000007FE0UL});
    public static readonly BitSet FOLLOW_assignment_operator_in_assignment_expression1335 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_assignment_expression_in_assignment_expression1337 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conditional_expression_in_assignment_expression1352 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_expression_in_lvalue1364 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_42_in_assignment_operator1375 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_69_in_assignment_operator1381 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_70_in_assignment_operator1387 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_71_in_assignment_operator1393 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_72_in_assignment_operator1399 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_73_in_assignment_operator1405 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_74_in_assignment_operator1411 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_75_in_assignment_operator1417 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_76_in_assignment_operator1423 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_77_in_assignment_operator1429 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_78_in_assignment_operator1435 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_logical_or_expression_in_conditional_expression1447 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_79_in_conditional_expression1450 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_conditional_expression1452 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_80_in_conditional_expression1454 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_conditional_expression_in_conditional_expression1456 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_logical_and_expression_in_logical_or_expression1469 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_81_in_logical_or_expression1472 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_logical_and_expression_in_logical_or_expression1476 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_inclusive_or_expression_in_logical_and_expression1489 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000040000UL});
    public static readonly BitSet FOLLOW_82_in_logical_and_expression1492 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_inclusive_or_expression_in_logical_and_expression1496 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000040000UL});
    public static readonly BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression1509 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_83_in_inclusive_or_expression1512 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression1516 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_and_expression_in_exclusive_or_expression1529 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_exclusive_or_expression1532 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_and_expression_in_exclusive_or_expression1536 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_equality_expression_in_and_expression1549 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_and_expression1552 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_equality_expression_in_and_expression1556 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_relational_expression_in_equality_expression1568 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000600000UL});
    public static readonly BitSet FOLLOW_85_in_equality_expression1572 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_86_in_equality_expression1575 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_relational_expression_in_equality_expression1580 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000600000UL});
    public static readonly BitSet FOLLOW_shift_expression_in_relational_expression1593 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000007800000UL});
    public static readonly BitSet FOLLOW_87_in_relational_expression1597 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_88_in_relational_expression1600 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_89_in_relational_expression1603 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_90_in_relational_expression1606 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_shift_expression_in_relational_expression1611 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000007800000UL});
    public static readonly BitSet FOLLOW_additive_expression_in_shift_expression1624 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000018000000UL});
    public static readonly BitSet FOLLOW_91_in_shift_expression1628 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_92_in_shift_expression1631 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_additive_expression_in_shift_expression1636 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000018000000UL});
    public static readonly BitSet FOLLOW_labeled_statement_in_statement1651 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_compound_statement_in_statement1657 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_statement_in_statement1662 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_selection_statement_in_statement1667 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_iteration_statement_in_statement1674 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_jump_statement_in_statement1681 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_comment_statement_in_statement1686 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_labeled_statement1698 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_80_in_labeled_statement1700 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_labeled_statement1702 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_93_in_labeled_statement1708 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_constant_expression_in_labeled_statement1711 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_80_in_labeled_statement1713 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_labeled_statement1715 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_94_in_labeled_statement1737 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_80_in_labeled_statement1740 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_labeled_statement1742 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_95_in_compound_statement1776 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000003E000001FUL});
    public static readonly BitSet FOLLOW_declaration_in_compound_statement1779 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000003E000001FUL});
    public static readonly BitSet FOLLOW_statement_list_in_compound_statement1782 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000100000000UL});
    public static readonly BitSet FOLLOW_96_in_compound_statement1785 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_in_statement_list1797 = new BitSet(new ulong[]{0x9D7B40003FDFE002UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_48_in_expression_statement1809 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expression_statement1815 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_expression_statement1817 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IF_in_selection_statement1830 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_selection_statement1835 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_selection_statement1837 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_selection_statement1839 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_selection_statement1843 = new BitSet(new ulong[]{0x0000000000200002UL});
    public static readonly BitSet FOLLOW_ELSE_in_selection_statement1863 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_selection_statement1870 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SWITCH_in_selection_statement1933 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_selection_statement1939 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_selection_statement1941 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_selection_statement1943 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_selection_statement1945 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WHILE_in_iteration_statement1975 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_iteration_statement1979 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_iteration_statement1981 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_iteration_statement1983 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_iteration_statement1985 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DO_in_iteration_statement2008 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_iteration_statement2012 = new BitSet(new ulong[]{0x0000000000800000UL});
    public static readonly BitSet FOLLOW_WHILE_in_iteration_statement2014 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_iteration_statement2016 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_iteration_statement2018 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_iteration_statement2020 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_iteration_statement2022 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FOR_in_iteration_statement2040 = new BitSet(new ulong[]{0x0002000000000000UL});
    public static readonly BitSet FOLLOW_49_in_iteration_statement2044 = new BitSet(new ulong[]{0x9C030000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_statement_in_iteration_statement2048 = new BitSet(new ulong[]{0x9C030000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_statement_in_iteration_statement2052 = new BitSet(new ulong[]{0x9C060000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_iteration_statement2058 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_iteration_statement2061 = new BitSet(new ulong[]{0x9D7B40003FDFE000UL,0x00000002E000001FUL});
    public static readonly BitSet FOLLOW_statement_in_iteration_statement2063 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_97_in_jump_statement2098 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_IDENTIFIER_in_jump_statement2100 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_jump_statement2102 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CONTINUE_in_jump_statement2108 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_jump_statement2113 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_BREAK_in_jump_statement2124 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_jump_statement2128 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LINE_COMMENT_in_comment_statement2147 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COMMENT_in_comment_statement2154 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_function_declaration_in_synpred7_Gxc310 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_49_in_synpred46_Gxc969 = new BitSet(new ulong[]{0x0178400000004000UL});
    public static readonly BitSet FOLLOW_type_specifier_in_synpred46_Gxc972 = new BitSet(new ulong[]{0x0004000000000000UL});
    public static readonly BitSet FOLLOW_50_in_synpred46_Gxc974 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_cast_expression_in_synpred46_Gxc977 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_synpred51_Gxc1021 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_unary_expression_in_synpred51_Gxc1023 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_synpred52_Gxc1047 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_synpred53_Gxc1060 = new BitSet(new ulong[]{0x0100000000000000UL});
    public static readonly BitSet FOLLOW_56_in_synpred53_Gxc1062 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_expression_in_synpred53_Gxc1064 = new BitSet(new ulong[]{0x0200000000000000UL});
    public static readonly BitSet FOLLOW_57_in_synpred53_Gxc1066 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_synpred54_Gxc1073 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_synpred54_Gxc1075 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_synpred55_Gxc1095 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_64_in_synpred55_Gxc1097 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lvalue_in_synpred71_Gxc1333 = new BitSet(new ulong[]{0x0000040000000000UL,0x0000000000007FE0UL});
    public static readonly BitSet FOLLOW_assignment_operator_in_synpred71_Gxc1335 = new BitSet(new ulong[]{0x9C020000000FE000UL,0x000000000000001FUL});
    public static readonly BitSet FOLLOW_assignment_expression_in_synpred71_Gxc1337 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}